name
stringlengths
1
473k
code
stringlengths
7
647k
asm
stringlengths
4
3.39M
file
stringlengths
8
196
Assimp::Ogre::SubMesh::SubMesh()
SubMesh::SubMesh() : vertexData(0), indexData(new IndexData()) { }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx movl $0x0, (%rdi) leaq 0x18(%rdi), %rax movq %rax, 0x8(%rdi) xorl %eax, %eax movq %rax, 0x10(%rdi) movb %al, 0x18(%rdi) leaq 0x38(%rdi), %rcx movq %rcx, 0x28(%rdi) movq %rax, 0x30(%rdi) movb %al, 0x38(%rdi) leaq 0x58(%rdi), %rcx movq %rcx, 0x48(%rdi) movq %rax, 0x50(%rdi) movb %al, 0x58(%rdi) leaq 0x78(%rdi), %rcx movq %rcx, 0x68(%rdi) movq %rax, 0x70(%rdi) movb %al, 0x78(%rdi) movl $0xffffffff, 0x88(%rdi) # imm = 0xFFFFFFFF movb %al, 0x8c(%rdi) movl $0x1, 0x90(%rdi) movq %rax, 0x98(%rdi) movl $0x20, %edi callq 0x1a5230 xorps %xmm0, %xmm0 movups %xmm0, 0x10(%rax) movq $0x0, (%rax) movb $0x0, 0x8(%rax) movq %rax, 0xa0(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movq %rbx, %rdi callq 0x31ac9e movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreStructs.cpp
Assimp::Ogre::Bone::ConvertToAssimpBone(Assimp::Ogre::Skeleton*, std::vector<aiVertexWeight, std::allocator<aiVertexWeight>> const&)
aiBone *Bone::ConvertToAssimpBone(Skeleton * /*parent*/, const std::vector<aiVertexWeight> &boneWeights) { aiBone *bone = new aiBone(); bone->mName = name; bone->mOffsetMatrix = worldMatrix; if (!boneWeights.empty()) { bone->mNumWeights = static_cast<unsigned int>(boneWeights.size()); bone->mWeights = new aiVertexWeight[boneWeights.size()]; memcpy(bone->mWeights, &boneWeights[0], boneWeights.size() * sizeof(aiVertexWeight)); } return bone; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax movq %rdx, %r14 movq %rdi, %r15 movl $0x450, %edi # imm = 0x450 callq 0x1a5230 movq %rax, %rbx xorl %ebp, %ebp movl %ebp, (%rax) movb $0x0, 0x4(%rax) leaq 0x5(%rax), %rdi movl $0x3ff, %edx # imm = 0x3FF movl $0x1b, %esi callq 0x1a54e0 movl %ebp, 0x404(%rbx) movq $0x0, 0x408(%rbx) leaq 0x410(%rbx), %r13 movq 0x10(%r15), %r12 cmpq $0x3ff, %r12 # imm = 0x3FF ja 0x318bdc movq %rbx, %rdi addq $0x4, %rdi movl %r12d, (%rbx) movq 0x8(%r15), %rsi movq %r12, %rdx callq 0x1a5110 movb $0x0, 0x4(%rbx,%r12) movups 0x78(%r15), %xmm0 movups 0x88(%r15), %xmm1 movups 0x98(%r15), %xmm2 movups 0xa8(%r15), %xmm3 movups %xmm3, 0x30(%r13) movups %xmm2, 0x20(%r13) movups %xmm1, 0x10(%r13) movups %xmm0, (%r13) movq (%r14), %r15 movq 0x8(%r14), %r14 cmpq %r14, %r15 je 0x318c6b subq %r15, %r14 movq %r14, %rax sarq $0x3, %rax movl %eax, 0x404(%rbx) shrq $0x3d, %rax xorl %edi, %edi negq %rax sbbq %rdi, %rdi orq %r14, %rdi callq 0x1a57a0 movq %rax, %r12 leaq -0x8(%r14), %rdx andq $-0x8, %rdx addq $0x8, %rdx movq %rax, %rdi xorl %esi, %esi callq 0x1a54e0 movq %r12, 0x408(%rbx) movq %r12, %rdi movq %r15, %rsi movq %r14, %rdx callq 0x1a5110 movq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreStructs.cpp
Assimp::Ogre::Skeleton::~Skeleton()
Skeleton::~Skeleton() { Reset(); }
pushq %rbx movq %rdi, %rbx callq 0x319e0c movq 0x18(%rbx), %rdi testq %rdi, %rdi je 0x319df4 movq 0x28(%rbx), %rsi subq %rdi, %rsi callq 0x1a5190 movq (%rbx), %rdi testq %rdi, %rdi je 0x319e09 movq 0x10(%rbx), %rsi subq %rdi, %rsi popq %rbx jmp 0x1a5190 popq %rbx retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreStructs.cpp
Assimp::Ogre::OgreBinarySerializer::ReadHeader(bool)
uint16_t OgreBinarySerializer::ReadHeader(bool readLen) { uint16_t id = Read<uint16_t>(); if (readLen) m_currentLen = Read<uint32_t>(); #if (OGRE_BINARY_SERIALIZER_DEBUG == 1) if (id != HEADER_CHUNK_ID) { ASSIMP_LOG_DEBUG(Formatter::format() << (assetMode == AM_Mesh ? MeshHeaderToString(static_cast<MeshChunkId>(id)) : SkeletonHeaderToString(static_cast<SkeletonChunkId>(id)))); } #endif return id; }
pushq %rbp pushq %r14 pushq %rbx movl %esi, %r14d movq %rdi, %rbx movq 0x8(%rdi), %rdi callq 0x3205e2 movl %eax, %ebp testl %r14d, %r14d je 0x31c1e1 movq 0x8(%rbx), %rdi callq 0x3206a0 movl %eax, (%rbx) movl %ebp, %eax popq %rbx popq %r14 popq %rbp retq
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreBinarySerializer.cpp
Assimp::Ogre::OgreBinarySerializer::ReadMeshLodInfo(Assimp::Ogre::Mesh*)
void OgreBinarySerializer::ReadMeshLodInfo(Mesh *mesh) { // Assimp does not acknowledge LOD levels as far as I can see it. This info is just skipped. // @todo Put this stuff to scene/mesh custom properties. If manual mesh the app can use the information. ReadLine(); // strategy name uint16_t numLods = Read<uint16_t>(); bool manual = Read<bool>(); /// @note Main mesh is considered as LOD 0, start from index 1. for (size_t i=1; i<numLods; ++i) { uint16_t id = ReadHeader(); if (id != M_MESH_LOD_USAGE) { throw DeadlyImportError("M_MESH_LOD does not contain a M_MESH_LOD_USAGE for each LOD level"); } m_reader->IncPtr(sizeof(float)); // user value if (manual) { id = ReadHeader(); if (id != M_MESH_LOD_MANUAL) { throw DeadlyImportError("Manual M_MESH_LOD_USAGE does not contain M_MESH_LOD_MANUAL"); } ReadLine(); // manual mesh name (ref to another mesh) } else { for(size_t si=0, silen=mesh->NumSubMeshes(); si<silen; ++si) { id = ReadHeader(); if (id != M_MESH_LOD_GENERATED) { throw DeadlyImportError("Generated M_MESH_LOD_USAGE does not contain M_MESH_LOD_GENERATED"); } uint32_t indexCount = Read<uint32_t>(); bool is32bit = Read<bool>(); if (indexCount > 0) { uint32_t len = indexCount * (is32bit ? sizeof(uint32_t) : sizeof(uint16_t)); m_reader->IncPtr(len); } } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x68, %rsp movq %rsi, 0x20(%rsp) movq %rdi, %r14 leaq 0x48(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x31c154 movq (%r15), %rdi leaq 0x58(%rsp), %rax cmpq %rax, %rdi je 0x31d19a movq 0x58(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x8(%r14), %rdi callq 0x3205e2 movl %eax, %r15d movq 0x8(%r14), %rdi callq 0x320524 cmpw $0x2, %r15w jb 0x31d2c7 movl %eax, %ebp movzwl %r15w, %r15d movl $0x1, %ebx movq 0x8(%r14), %rdi callq 0x3205e2 movl %eax, %r12d movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movzwl %r12w, %eax cmpl $0x8100, %eax # imm = 0x8100 jne 0x31d337 movq 0x8(%r14), %rdi movl $0x4, %esi callq 0x27f688 testb %bpl, %bpl je 0x31d251 movq 0x8(%r14), %rdi callq 0x3205e2 movl %eax, %r12d movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movzwl %r12w, %eax cmpl $0x8110, %eax # imm = 0x8110 jne 0x31d395 leaq 0x28(%rsp), %rdi movq %r14, %rsi callq 0x31c154 movq 0x28(%rsp), %rdi leaq 0x38(%rsp), %rax cmpq %rax, %rdi je 0x31d2bb movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x31d2bb movq 0x20(%rsp), %rdi callq 0x31736e testq %rax, %rax je 0x31d2bb movq %rax, %r12 movq 0x8(%r14), %rdi callq 0x3205e2 movl %eax, %r13d movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movzwl %r13w, %eax cmpl $0x8120, %eax # imm = 0x8120 jne 0x31d2d6 movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, %r13d movq 0x8(%r14), %rdi callq 0x320524 testl %r13d, %r13d je 0x31d2b6 cmpb $0x1, %al movb $0x2, %cl sbbb $0x0, %cl shll %cl, %r13d movq 0x8(%r14), %rdi movq %r13, %rsi callq 0x27f688 decq %r12 jne 0x31d263 incq %rbx cmpq %r15, %rbx jne 0x31d1c5 addq $0x68, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x288456(%rip), %rsi # 0x5a5749 leaq 0x28848f(%rip), %rdx # 0x5a5789 movq %rsp, %rdi callq 0x209290 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3c0421(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3c03ed(%rip), %rsi # 0x6dd710 movq 0x48ec36(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 jmp 0x31d3f1 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x288378(%rip), %rsi # 0x5a56cc leaq 0x2883b2(%rip), %rdx # 0x5a570d movq %rsp, %rdi callq 0x209290 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3c03c0(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3c038c(%rip), %rsi # 0x6dd710 movq 0x48ebd5(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 jmp 0x31d3f1 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x28835c(%rip), %rsi # 0x5a570e leaq 0x28838f(%rip), %rdx # 0x5a5748 movq %rsp, %rdi callq 0x209290 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3c0362(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3c032e(%rip), %rsi # 0x6dd710 movq 0x48eb77(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 jmp 0x31d3f9 jmp 0x31d419 jmp 0x31d3f9 jmp 0x31d419 movq %rax, %r14 movq (%rsp), %rdi cmpq %r15, %rdi je 0x31d412 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x31d41c jmp 0x31d424 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreBinarySerializer.cpp
Assimp::Ogre::OgreBinarySerializer::ReadPoses(Assimp::Ogre::Mesh*)
void OgreBinarySerializer::ReadPoses(Mesh *mesh) { if (!AtEnd()) { uint16_t id = ReadHeader(); while (!AtEnd() && id == M_POSE) { Pose *pose = new Pose(); pose->name = ReadLine(); pose->target = Read<uint16_t>(); pose->hasNormals = Read<bool>(); ReadPoseVertices(pose); mesh->poses.push_back(pose); if (!AtEnd()) id = ReadHeader(); } if (!AtEnd()) RollbackHeader(); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdi, %r14 movq 0x8(%rdi), %rdi movl 0x20(%rdi), %eax cmpl 0x18(%rdi), %eax je 0x31da84 movq %rsi, %rbx callq 0x3205e2 movl %eax, %ebp movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movq 0x8(%r14), %rdi movl 0x20(%rdi), %ecx subl 0x18(%rdi), %ecx sete %al movzwl %bp, %edx cmpl $0xc100, %edx # imm = 0xC100 jne 0x31da74 testq %rcx, %rcx je 0x31da74 leaq 0x28(%rsp), %r13 leaq 0x68(%rbx), %rax movq %rax, 0x10(%rsp) xorl %r15d, %r15d leaq 0x18(%rsp), %r12 movl $0x58, %edi callq 0x1a5230 leaq 0x10(%rax), %rcx movq %rcx, (%rax) movq %r15, 0x8(%rax) movb %r15b, 0x10(%rax) movw $0x0, 0x20(%rax) movb %r15b, 0x22(%rax) leaq 0x30(%rax), %rcx movl $0x0, 0x30(%rax) movq %r15, 0x38(%rax) movq %rcx, 0x40(%rax) movq %rcx, 0x48(%rax) movq %r15, 0x50(%rax) movq %rax, 0x8(%rsp) movq %r12, %rdi movq %r14, %rsi callq 0x31c154 movq 0x8(%rsp), %rdi movq %r12, %rsi callq 0x1a58d0 movq 0x18(%rsp), %rdi cmpq %r13, %rdi je 0x31d9de movq 0x28(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x8(%r14), %rdi callq 0x3205e2 movq 0x8(%rsp), %rcx movw %ax, 0x20(%rcx) movq 0x8(%r14), %rdi callq 0x320524 testb %al, %al movq 0x8(%rsp), %rsi setne 0x22(%rsi) movq %r14, %rdi callq 0x31e418 movq 0x70(%rbx), %rsi cmpq 0x78(%rbx), %rsi je 0x31da25 movq 0x8(%rsp), %rax movq %rax, (%rsi) addq $0x8, 0x70(%rbx) jmp 0x31da34 movq 0x10(%rsp), %rdi leaq 0x8(%rsp), %rdx callq 0x320cc4 movq 0x8(%r14), %rdi movl 0x20(%rdi), %eax cmpl 0x18(%rdi), %eax je 0x31da84 callq 0x3205e2 movl %eax, %ebp movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movzwl %bp, %edx movq 0x8(%r14), %rdi movl 0x20(%rdi), %ecx subl 0x18(%rdi), %ecx sete %al cmpl $0xc100, %edx # imm = 0xC100 jne 0x31da74 testq %rcx, %rcx jne 0x31d96c testb %al, %al jne 0x31da84 movq $-0x6, %rsi callq 0x27f688 addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreBinarySerializer.cpp
Assimp::Ogre::OgreBinarySerializer::ReadAnimation(Assimp::Ogre::Animation*)
void OgreBinarySerializer::ReadAnimation(Animation *anim) { if (!AtEnd()) { uint16_t id = ReadHeader(); if (id == M_ANIMATION_BASEINFO) { anim->baseName = ReadLine(); anim->baseTime = Read<float>(); // Advance to first track id = ReadHeader(); } while (!AtEnd() && id == M_ANIMATION_TRACK) { VertexAnimationTrack track; track.type = static_cast<VertexAnimationTrack::Type>(Read<uint16_t>()); track.target = Read<uint16_t>(); ReadAnimationKeyFrames(anim, &track); anim->tracks.push_back(track); if (!AtEnd()) id = ReadHeader(); } if (!AtEnd()) RollbackHeader(); } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x78, %rsp movq %rdi, %r14 movq 0x8(%rdi), %rdi movl 0x20(%rdi), %eax cmpl 0x18(%rdi), %eax je 0x31e715 movq %rsi, %rbx callq 0x3205e2 movl %eax, %ebp movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movzwl %bp, %eax cmpl $0xd105, %eax # imm = 0xD105 jne 0x31e602 leaq 0x8(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x31c154 leaq 0x30(%rbx), %rdi movq %r15, %rsi callq 0x1a58d0 movq (%r15), %rdi leaq 0x18(%rsp), %rax cmpq %rax, %rdi je 0x31e5dd movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x8(%r14), %rdi callq 0x2811f2 movss %xmm0, 0x54(%rbx) movq 0x8(%r14), %rdi callq 0x3205e2 movl %eax, %ebp movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movq 0x8(%r14), %rdi movl 0x20(%rdi), %ecx subl 0x18(%rdi), %ecx sete %al movzwl %bp, %edx cmpl $0xd110, %edx # imm = 0xD110 jne 0x31e705 testq %rcx, %rcx je 0x31e705 leaq 0x58(%rbx), %r15 leaq 0x30(%rsp), %r13 leaq 0x8(%rsp), %rbp movq %rbp, %rdi callq 0x31a8c4 movq 0x8(%r14), %rdi callq 0x3205e2 movzwl %ax, %eax movl %eax, 0x8(%rsp) movq 0x8(%r14), %rdi callq 0x3205e2 movw %ax, 0xc(%rsp) movq %r14, %rdi movq %rbx, %rsi movq %rbp, %rdx callq 0x31e73a movq %r15, %rdi movq %rbp, %rsi callq 0x32042e movq 0x8(%r14), %rdi movl 0x20(%rdi), %eax cmpl 0x18(%rdi), %eax je 0x31e6a3 callq 0x3205e2 movl %eax, %r12d movq 0x8(%r14), %rdi callq 0x3206a0 movl %eax, (%r14) movzwl %r12w, %eax cmpl $0xd110, %eax # imm = 0xD110 setne %r12b jmp 0x31e6a6 xorl %r12d, %r12d movq 0x60(%rsp), %rdi testq %rdi, %rdi je 0x31e6bd movq 0x70(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 leaq 0x48(%rsp), %rdi callq 0x31b042 movq %r13, %rdi callq 0x31b090 movq 0x10(%rsp), %rdi leaq 0x20(%rsp), %rax cmpq %rax, %rdi je 0x31e6eb movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x8(%r14), %rdi movl 0x20(%rdi), %eax cmpl 0x18(%rdi), %eax sete %al orb %al, %r12b cmpb $0x1, %r12b jne 0x31e635 testb %al, %al jne 0x31e715 movq $-0x6, %rsi callq 0x27f688 addq $0x78, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x8(%rsp), %rdi callq 0x320458 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreBinarySerializer.cpp
Assimp::Ogre::OgreBinarySerializer::ReadSkeletonAnimation(Assimp::Ogre::Skeleton*)
void OgreBinarySerializer::ReadSkeletonAnimation(Skeleton *skeleton) { Animation *anim = new Animation(skeleton); anim->name = ReadLine(); anim->length = Read<float>(); if (!AtEnd()) { uint16_t id = ReadHeader(); if (id == SKELETON_ANIMATION_BASEINFO) { anim->baseName = ReadLine(); anim->baseTime = Read<float>(); // Advance to first track id = ReadHeader(); } while (!AtEnd() && id == SKELETON_ANIMATION_TRACK) { ReadSkeletonAnimationTrack(skeleton, anim); if (!AtEnd()) id = ReadHeader(); } if (!AtEnd()) RollbackHeader(); } skeleton->animations.push_back(anim); ASSIMP_LOG_DEBUG_F( " ", anim->name, " (", anim->length, " sec, ", anim->tracks.size(), " tracks)"); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rsi, %rbx movq %rdi, %r15 movl $0x70, %edi callq 0x1a5230 movq %rax, %r14 movq %rax, %rdi movq %rbx, %rsi callq 0x3196cc movq %r14, 0x8(%rsp) leaq 0x30(%rsp), %r12 movq %r12, %rdi movq %r15, %rsi callq 0x31c154 leaq 0x10(%r14), %rdi movq %r12, %rsi callq 0x1a58d0 movq (%r12), %rdi leaq 0x40(%rsp), %r13 cmpq %r13, %rdi je 0x31fba5 movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x8(%r15), %rdi callq 0x2811f2 movss %xmm0, 0x50(%r14) movq 0x8(%r15), %rdi movl 0x20(%rdi), %eax cmpl 0x18(%rdi), %eax je 0x31fca5 callq 0x3205e2 movl %eax, %ebp movq 0x8(%r15), %rdi callq 0x3206a0 movl %eax, (%r15) movzwl %bp, %eax cmpl $0x4010, %eax # imm = 0x4010 jne 0x31fc3c leaq 0x30(%rsp), %r12 movq %r12, %rdi movq %r15, %rsi callq 0x31c154 movq %r14, %rdi addq $0x30, %rdi movq %r12, %rsi callq 0x1a58d0 movq (%r12), %rdi cmpq %r13, %rdi je 0x31fc16 movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x8(%r15), %rdi callq 0x2811f2 movss %xmm0, 0x54(%r14) movq 0x8(%r15), %rdi callq 0x3205e2 movl %eax, %ebp movq 0x8(%r15), %rdi callq 0x3206a0 movl %eax, (%r15) movq 0x8(%r15), %rdi movl 0x20(%rdi), %ecx subl 0x18(%rdi), %ecx sete %al movzwl %bp, %edx cmpl $0x4100, %edx # imm = 0x4100 jne 0x31fc95 testq %rcx, %rcx je 0x31fc95 movq %r15, %rdi movq %r14, %rdx callq 0x31fe90 movq 0x8(%r15), %rdi movl 0x20(%rdi), %eax cmpl 0x18(%rdi), %eax je 0x31fca5 callq 0x3205e2 movl %eax, %ebp movq 0x8(%r15), %rdi callq 0x3206a0 movl %eax, (%r15) movzwl %bp, %edx movq 0x8(%r15), %rdi movl 0x20(%rdi), %ecx subl 0x18(%rdi), %ecx sete %al jmp 0x31fc4c testb %al, %al jne 0x31fca5 movq $-0x6, %rsi callq 0x27f688 movq 0x20(%rbx), %rsi cmpq 0x28(%rbx), %rsi je 0x31fcbe movq 0x8(%rsp), %rax movq %rax, (%rsi) addq $0x8, 0x20(%rbx) jmp 0x31fccf addq $0x18, %rbx leaq 0x8(%rsp), %rdx movq %rbx, %rdi callq 0x321008 callq 0x241234 movq %rax, %rbx leaq 0x23f62b(%rip), %rsi # 0x55f309 leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x320224 movq 0x8(%rsp), %rax movq 0x10(%rax), %rsi movq 0x18(%rax), %rdx movq %r14, %rdi callq 0x1a61e0 leaq 0x2b67d3(%rip), %rsi # 0x5d64da leaq 0x30(%rsp), %rdi movl $0x2, %edx callq 0x1a61e0 movq 0x8(%rsp), %rax xorps %xmm0, %xmm0 cvtss2sd 0x50(%rax), %xmm0 leaq 0x30(%rsp), %rdi callq 0x1a5df0 leaq 0x285e98(%rip), %rsi # 0x5a5bcc leaq 0x30(%rsp), %rdi movl $0x6, %edx callq 0x1a61e0 movq 0x8(%rsp), %rax movq 0x60(%rax), %rcx subq 0x58(%rax), %rcx sarq $0x4, %rcx movabsq $0x6db6db6db6db6db7, %rsi # imm = 0x6DB6DB6DB6DB6DB7 imulq %rcx, %rsi leaq 0x30(%rsp), %rdi callq 0x1a5850 leaq 0x285e60(%rip), %rsi # 0x5a5bd3 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 0x241112 leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x31fdb9 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x48c1d0(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x31fe20 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x31fe20 movq %rax, %rbx movl $0x70, %esi movq %r14, %rdi callq 0x1a5190 jmp 0x31fe3e jmp 0x31fe1d movq %rax, %rbx movq 0x48c169(%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/Ogre/OgreBinarySerializer.cpp
unsigned char Assimp::StreamReader<false, false>::Get<unsigned char>()
T Get() { if ( current + sizeof(T) > limit) { throw DeadlyImportError("End of file or stream limit was reached"); } T f; ::memcpy (&f, current, sizeof(T)); Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le); current += sizeof(T); return f; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq 0x18(%rdi), %rax leaq 0x1(%rax), %rcx cmpq 0x28(%rdi), %rcx ja 0x32054d movb (%rax), %al movq %rcx, 0x18(%rdi) addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x277c68(%rip), %rsi # 0x5981d2 leaq 0x277c88(%rip), %rdx # 0x5981f9 leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3bd1a6(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3bd172(%rip), %rsi # 0x6dd710 movq 0x48b9bb(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x3205c7 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x3205d1 jmp 0x3205d9 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/include/assimp/StreamReader.h
Assimp::Ogre::OgreXmlSerializer::NextNode[abi:cxx11]()
std::string &OgreXmlSerializer::NextNode() { do { if (!m_reader->read()) { m_currentNodeName = ""; return m_currentNodeName; } } while(m_reader->getNodeType() != irr::io::EXN_ELEMENT); CurrentNodeName(true); #if (OGRE_XML_SERIALIZER_DEBUG == 1) ASSIMP_LOG_DEBUG"<" + m_currentNodeName + ">"); #endif return m_currentNodeName; }
pushq %r14 pushq %rbx subq $0x28, %rsp movq %rdi, %rbx movq (%rbx), %rdi movq (%rdi), %rax callq *0x10(%rax) testb %al, %al je 0x322c60 movq (%rbx), %rdi movq (%rdi), %rax callq *0x18(%rax) cmpl $0x1, %eax jne 0x322c10 leaq 0x8(%rsp), %r14 movq %r14, %rdi movq %rbx, %rsi movl $0x1, %edx callq 0x322c88 movq (%r14), %rdi leaq 0x18(%rsp), %rax cmpq %rax, %rdi je 0x322c5a movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x8, %rbx jmp 0x322c7c movq 0x10(%rbx), %rdx addq $0x8, %rbx leaq 0x285ed2(%rip), %rcx # 0x5a8b41 movq %rbx, %rdi xorl %esi, %esi xorl %r8d, %r8d callq 0x1a5830 movq %rbx, %rax addq $0x28, %rsp popq %rbx popq %r14 retq nop
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreXmlSerializer.cpp
Assimp::Ogre::OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem*, Assimp::Ogre::Mesh*)
bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh) { if (!mesh || mesh->skeletonRef.empty()) return false; XmlReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef); if (!reader.get()) return false; Skeleton *skeleton = new Skeleton(); OgreXmlSerializer serializer(reader.get()); serializer.ReadSkeleton(skeleton); mesh->skeleton = skeleton; return true; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, %r14 testq %rsi, %rsi je 0x3259c4 cmpq $0x0, 0x10(%r14) je 0x3259c4 movq %rdi, %rsi leaq 0x8(%r14), %rdx movq %rsp, %rbx movq %rbx, %rdi callq 0x3251fe cmpq $0x0, (%rbx) setne %bl je 0x3259b3 movl $0x38, %edi callq 0x1a5230 movq %rax, %r15 movq %rax, %rdi callq 0x319dc0 movq (%rsp), %rax leaq 0x28(%rsp), %r12 movq %rax, -0x18(%r12) movq %r12, -0x10(%r12) movq $0x0, -0x8(%r12) movb $0x0, (%r12) leaq 0x10(%rsp), %rdi movq %r15, %rsi callq 0x3255f4 movq %r15, 0x28(%r14) movq 0x18(%rsp), %rdi cmpq %r12, %rdi je 0x3259b3 movq 0x28(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x3259c6 callq 0x280464 jmp 0x3259c6 xorl %ebx, %ebx movl %ebx, %eax addq $0x38, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %rbx movq 0x18(%rsp), %rdi cmpq %r12, %rdi je 0x325a00 movq 0x28(%rsp), %rsi incq %rsi jmp 0x3259f6 movq %rax, %rbx movl $0x38, %esi movq %r15, %rdi callq 0x1a5190 jmp 0x325a00 movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x325a0f callq 0x280464 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreXmlSerializer.cpp
Assimp::Ogre::OgreImporter::ReadTechnique(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, aiMaterial*)
bool OgreImporter::ReadTechnique(const std::string &techniqueName, stringstream &ss, aiMaterial *material) { string linePart; ss >> linePart; if (linePart != partBlockStart) { ASSIMP_LOG_ERROR_F( "Invalid material: Technique block start missing near index ", ss.tellg()); return false; } ASSIMP_LOG_DEBUG_F(" technique '", techniqueName, "'"); const string partPass = "pass"; while(linePart != partBlockEnd) { ss >> linePart; // Skip commented lines if (linePart == partComment) { SkipLine(ss); continue; } /// @todo Techniques have other attributes than just passes. if (linePart == partPass) { string passName = SkipLine(ss); ReadPass(Trim(passName), ss, material); } } return true; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1e8, %rsp # imm = 0x1E8 movq %rcx, 0x68(%rsp) movq %rdx, %rbx movq %rsi, %r12 movq %rdi, 0x60(%rsp) leaq 0x30(%rsp), %rax movq %rax, -0x10(%rax) movq $0x0, -0x8(%rax) movb $0x0, (%rax) leaq 0x20(%rsp), %rsi movq %rdx, %rdi callq 0x1a5740 movq 0x28(%rsp), %rdx cmpq 0x4b2288(%rip), %rdx # 0x7db688 jne 0x329424 testq %rdx, %rdx je 0x3294ab movq 0x4b226e(%rip), %rsi # 0x7db680 movq 0x20(%rsp), %rdi callq 0x1a5c20 testl %eax, %eax je 0x3294ab callq 0x241234 movq %rax, %r14 leaq 0x27d198(%rip), %rsi # 0x5a65cb leaq 0x70(%rsp), %rdi callq 0x32b3c0 movq %rbx, %rdi callq 0x1a51d0 leaq 0x70(%rsp), %rdi movq %rax, %rsi callq 0x1a5620 leaq 0x78(%rsp), %rsi movq %rsp, %rdi callq 0x1a5690 movq (%rsp), %rsi movq %r14, %rdi callq 0x2411ba leaq 0x10(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x329486 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x482b03(%rip), %rsi # 0x7abf90 leaq 0x70(%rsp), %rdi callq 0x1a5d00 leaq 0xe0(%rsp), %rdi callq 0x1a5ca0 xorl %ebx, %ebx jmp 0x3296e4 callq 0x241234 movq %rax, %r13 leaq 0x27d14d(%rip), %rsi # 0x5a6607 leaq 0x70(%rsp), %rdi callq 0x320278 movq (%r12), %rsi movq 0x8(%r12), %rdx leaq 0x70(%rsp), %rdi callq 0x1a61e0 leaq 0x27c2fe(%rip), %rsi # 0x5a57dc leaq 0x70(%rsp), %rdi movl $0x1, %edx callq 0x1a61e0 leaq 0x78(%rsp), %rsi movq %rsp, %rdi callq 0x1a5690 movq (%rsp), %rsi movq %r13, %rdi callq 0x241112 leaq 0x10(%rsp), %r14 movq -0x10(%r14), %rdi cmpq %r14, %rdi je 0x329521 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x482a68(%rip), %rsi # 0x7abf90 leaq 0x70(%rsp), %rdi callq 0x1a5d00 leaq 0xe0(%rsp), %rdi callq 0x1a5ca0 leaq 0x80(%rsp), %rax movq %rax, -0x10(%rax) leaq 0x27d0c2(%rip), %rsi # 0x5a6614 leaq 0x27d0bf(%rip), %rdx # 0x5a6618 leaq 0x70(%rsp), %rdi callq 0x209290 leaq 0x50(%rsp), %r15 leaq 0x20(%rsp), %r12 movq %rsp, %rbp movq 0x28(%rsp), %rdx cmpq 0x4b212c(%rip), %rdx # 0x7db6a8 jne 0x3295a0 testq %rdx, %rdx je 0x3296c0 movq 0x4b2112(%rip), %rsi # 0x7db6a0 movq 0x20(%rsp), %rdi callq 0x1a5c20 testl %eax, %eax je 0x3296c0 movq %rbx, %rdi movq %r12, %rsi callq 0x1a5740 movq 0x28(%rsp), %r13 cmpq 0x4b20b1(%rip), %r13 # 0x7db668 jne 0x3295de testq %r13, %r13 je 0x329669 movq 0x4b2097(%rip), %rsi # 0x7db660 movq 0x20(%rsp), %rdi movq %r13, %rdx callq 0x1a5c20 testl %eax, %eax je 0x329669 cmpq 0x78(%rsp), %r13 jne 0x329570 testq %r13, %r13 je 0x329604 movq 0x70(%rsp), %rsi movq 0x20(%rsp), %rdi movq %r13, %rdx callq 0x1a5c20 testl %eax, %eax jne 0x329570 movq %r14, (%rsp) movq $0x0, 0x8(%rsp) movb $0x0, 0x10(%rsp) movq (%rbx), %rax movq -0x18(%rax), %rdi addq %rbx, %rdi movl $0xa, %esi callq 0x1a6320 movsbl %al, %edx movq %rbx, %rdi movq %rbp, %rsi callq 0x1a5070 movq %rbp, %rdi callq 0x3297e0 movq 0x60(%rsp), %rdi movq %rbp, %rsi movq %rbx, %rdx movq 0x68(%rsp), %rcx callq 0x329a74 movq (%rsp), %rdi cmpq %r14, %rdi je 0x329570 movq 0x10(%rsp), %rsi jmp 0x3296b3 movq %r15, 0x40(%rsp) movq $0x0, 0x48(%rsp) movb $0x0, 0x50(%rsp) movq (%rbx), %rax movq -0x18(%rax), %rdi addq %rbx, %rdi movl $0xa, %esi callq 0x1a6320 movsbl %al, %edx movq %rbx, %rdi leaq 0x40(%rsp), %rsi callq 0x1a5070 movq 0x40(%rsp), %rdi cmpq %r15, %rdi je 0x329570 movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x329570 movq 0x70(%rsp), %rdi leaq 0x80(%rsp), %rax cmpq %rax, %rdi je 0x3296e2 movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 movb $0x1, %bl movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x329700 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movl %ebx, %eax addq $0x1e8, %rsp # imm = 0x1E8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq jmp 0x32973e jmp 0x32971a jmp 0x32973e movq %rax, %rbx leaq 0x10(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x329746 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x329746 jmp 0x32973e jmp 0x329743 movq %rax, %rbx jmp 0x3297bc movq %rax, %rbx movq 0x482843(%rip), %rsi # 0x7abf90 leaq 0x70(%rsp), %rdi callq 0x1a5d00 leaq 0xe0(%rsp), %rdi callq 0x1a5ca0 jmp 0x3297bc jmp 0x329768 movq %rax, %rbx movq (%rsp), %rdi cmpq %r14, %rdi je 0x32979a movq 0x10(%rsp), %rsi jmp 0x32978d movq %rax, %rbx movq 0x40(%rsp), %rdi cmpq %r15, %rdi je 0x32979a movq 0x50(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x32979a movq %rax, %rbx movq 0x70(%rsp), %rdi leaq 0x80(%rsp), %rax cmpq %rax, %rdi je 0x3297bc movq 0x80(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x20(%rsp), %rdi leaq 0x30(%rsp), %rax cmpq %rax, %rdi je 0x3297d8 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreMaterial.cpp
Assimp::PLYImporter::LoadFace(Assimp::PLY::Element const*, Assimp::PLY::ElementInstance const*, unsigned int)
void PLYImporter::LoadFace(const PLY::Element* pcElement, const PLY::ElementInstance* instElement, unsigned int pos) { ai_assert(nullptr != pcElement); ai_assert(nullptr != instElement); if (mGeneratedMesh == nullptr) { throw DeadlyImportError("Invalid .ply file: Vertices should be declared before faces"); } bool bOne = false; // index of the vertex index list unsigned int iProperty = 0xFFFFFFFF; PLY::EDataType eType = EDT_Char; bool bIsTriStrip = false; // index of the material index property //unsigned int iMaterialIndex = 0xFFFFFFFF; //PLY::EDataType eType2 = EDT_Char; // texture coordinates unsigned int iTextureCoord = 0xFFFFFFFF; PLY::EDataType eType3 = EDT_Char; // face = unique number of vertex indices if (PLY::EEST_Face == pcElement->eSemantic) { unsigned int _a = 0; for (std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin(); a != pcElement->alProperties.end(); ++a, ++_a) { if (PLY::EST_VertexIndex == (*a).Semantic) { // must be a dynamic list! if (!(*a).bIsList) { continue; } iProperty = _a; bOne = true; eType = (*a).eType; } else if (PLY::EST_TextureCoordinates == (*a).Semantic) { // must be a dynamic list! if (!(*a).bIsList) { continue; } iTextureCoord = _a; bOne = true; eType3 = (*a).eType; } } } // triangle strip // TODO: triangle strip and material index support??? else if (PLY::EEST_TriStrip == pcElement->eSemantic) { unsigned int _a = 0; for (std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin(); a != pcElement->alProperties.end(); ++a, ++_a) { // must be a dynamic list! if (!(*a).bIsList) { continue; } iProperty = _a; bOne = true; bIsTriStrip = true; eType = (*a).eType; break; } } // check whether we have at least one per-face information set if (bOne) { if (mGeneratedMesh->mFaces == nullptr) { mGeneratedMesh->mNumFaces = pcElement->NumOccur; mGeneratedMesh->mFaces = new aiFace[mGeneratedMesh->mNumFaces]; } if (!bIsTriStrip) { // parse the list of vertex indices if (0xFFFFFFFF != iProperty) { const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iProperty).avList.size(); mGeneratedMesh->mFaces[pos].mNumIndices = iNum; mGeneratedMesh->mFaces[pos].mIndices = new unsigned int[iNum]; std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator p = GetProperty(instElement->alProperties, iProperty).avList.begin(); for (unsigned int a = 0; a < iNum; ++a, ++p) { mGeneratedMesh->mFaces[pos].mIndices[a] = PLY::PropertyInstance::ConvertTo<unsigned int>(*p, eType); } } // parse the material index // cannot be handled without processing the whole file first /*if (0xFFFFFFFF != iMaterialIndex) { mGeneratedMesh->mFaces[pos]. = PLY::PropertyInstance::ConvertTo<unsigned int>( GetProperty(instElement->alProperties, iMaterialIndex).avList.front(), eType2); }*/ if (0xFFFFFFFF != iTextureCoord) { const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iTextureCoord).avList.size(); //should be 6 coords std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator p = GetProperty(instElement->alProperties, iTextureCoord).avList.begin(); if ((iNum / 3) == 2) // X Y coord { for (unsigned int a = 0; a < iNum; ++a, ++p) { unsigned int vindex = mGeneratedMesh->mFaces[pos].mIndices[a / 2]; if (vindex < mGeneratedMesh->mNumVertices) { if (mGeneratedMesh->mTextureCoords[0] == nullptr ) { mGeneratedMesh->mNumUVComponents[0] = 2; mGeneratedMesh->mTextureCoords[0] = new aiVector3D[mGeneratedMesh->mNumVertices]; } if (a % 2 == 0) { mGeneratedMesh->mTextureCoords[0][vindex].x = PLY::PropertyInstance::ConvertTo<ai_real>(*p, eType3); } else { mGeneratedMesh->mTextureCoords[0][vindex].y = PLY::PropertyInstance::ConvertTo<ai_real>(*p, eType3); } mGeneratedMesh->mTextureCoords[0][vindex].z = 0; } } } } } else { // triangle strips // normally we have only one triangle strip instance where // a value of -1 indicates a restart of the strip bool flip = false; const std::vector<PLY::PropertyInstance::ValueUnion>& quak = GetProperty(instElement->alProperties, iProperty).avList; //pvOut->reserve(pvOut->size() + quak.size() + (quak.size()>>2u)); //Limits memory consumption int aiTable[2] = { -1, -1 }; for (std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator a = quak.begin(); a != quak.end(); ++a) { const int p = PLY::PropertyInstance::ConvertTo<int>(*a, eType); if (-1 == p) { // restart the strip ... aiTable[0] = aiTable[1] = -1; flip = false; continue; } if (-1 == aiTable[0]) { aiTable[0] = p; continue; } if (-1 == aiTable[1]) { aiTable[1] = p; continue; } if (mGeneratedMesh->mFaces == nullptr) { mGeneratedMesh->mNumFaces = pcElement->NumOccur; mGeneratedMesh->mFaces = new aiFace[mGeneratedMesh->mNumFaces]; } mGeneratedMesh->mFaces[pos].mNumIndices = 3; mGeneratedMesh->mFaces[pos].mIndices = new unsigned int[3]; mGeneratedMesh->mFaces[pos].mIndices[0] = aiTable[0]; mGeneratedMesh->mFaces[pos].mIndices[1] = aiTable[1]; mGeneratedMesh->mFaces[pos].mIndices[2] = p; // every second pass swap the indices. flip = !flip; if ( flip ) { std::swap(mGeneratedMesh->mFaces[pos].mIndices[0], mGeneratedMesh->mFaces[pos].mIndices[1]); } aiTable[0] = aiTable[1]; aiTable[1] = p; } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x58, %rsp testq %rsi, %rsi je 0x332a2f movq %rdx, %r15 testq %rdx, %rdx je 0x332a4e movq %rdi, %r13 movq 0x88(%rdi), %rax testq %rax, %rax je 0x332a6d movl %ecx, %ebp movl 0x18(%rsi), %ecx cmpl $0x2, %ecx je 0x3323e5 cmpl $0x1, %ecx jne 0x332a20 movq (%rsi), %rdx movq 0x8(%rsi), %r10 cmpq %r10, %rdx je 0x332a20 xorl %ecx, %ecx movl $0xffffffff, %r12d # imm = 0xFFFFFFFF xorl %r9d, %r9d movl $0xffffffff, %r11d # imm = 0xFFFFFFFF xorl %ebx, %ebx xorl %edi, %edi movl 0x4(%rdx), %r8d cmpl $0xe, %r8d je 0x3323c4 cmpl $0xc, %r8d jne 0x3323d1 cmpb $0x1, 0x28(%rdx) jne 0x3323d1 movl (%rdx), %r9d movb $0x1, %cl movl %edi, %r12d jmp 0x3323d1 cmpb $0x1, 0x28(%rdx) jne 0x3323d1 movl (%rdx), %ebx movb $0x1, %cl movl %edi, %r11d addq $0x30, %rdx incl %edi cmpq %r10, %rdx jne 0x3323a4 movl %r11d, (%rsp) xorl %r14d, %r14d jmp 0x33242d movq (%rsi), %rcx movq 0x8(%rsi), %rdx xorl %ebx, %ebx cmpq %rdx, %rcx je 0x332408 xorl %r12d, %r12d cmpb $0x1, 0x28(%rcx) je 0x33241d addq $0x30, %rcx incl %r12d cmpq %rdx, %rcx jne 0x3323f6 movl $0xffffffff, (%rsp) # imm = 0xFFFFFFFF xorl %r9d, %r9d movl $0xffffffff, %r12d # imm = 0xFFFFFFFF xorl %r14d, %r14d jmp 0x33242a movl $0xffffffff, (%rsp) # imm = 0xFFFFFFFF movl (%rcx), %r9d movb $0x1, %r14b movl %r14d, %ecx testb $0x1, %cl je 0x332a20 cmpq $0x0, 0xd0(%rax) movl %r9d, 0x20(%rsp) movq %rsi, 0x10(%rsp) jne 0x3324be movl %ebp, 0x8(%rsp) movl %ebx, 0x18(%rsp) movl 0x40(%rsi), %ecx movl %ecx, 0x8(%rax) movq 0x88(%r13), %rax movq %rax, 0x48(%rsp) movl 0x8(%rax), %ebp movq %rbp, %rbx shlq $0x4, %rbx leaq 0x8(%rbx), %rdi callq 0x1a57a0 leaq 0x8(%rax), %rcx movq %rbp, (%rax) testq %rbp, %rbp je 0x3324a0 addq %rcx, %rbx movq %rcx, %rax movl $0x0, (%rax) movq $0x0, 0x8(%rax) addq $0x10, %rax cmpq %rbx, %rax jne 0x332489 movq 0x48(%rsp), %rax movq %rcx, 0xd0(%rax) movl 0x18(%rsp), %ebx movl 0x20(%rsp), %r9d movq 0x10(%rsp), %rsi movl 0x8(%rsp), %ebp movabsq $-0x5555555555555555, %r11 # imm = 0xAAAAAAAAAAAAAAAB testb %r14b, %r14b je 0x3326ef movq (%r15), %rax movq 0x8(%r15), %rdx movslq %r12d, %rcx subq %rax, %rdx sarq $0x3, %rdx imulq %r11, %rdx cmpq %rcx, %rdx jbe 0x332acd leaq (%rcx,%rcx,2), %rcx movq (%rax,%rcx,8), %r15 cmpq 0x8(%rax,%rcx,8), %r15 je 0x332a20 leaq (%rax,%rcx,8), %rcx movl %ebp, %eax movq %rax, 0x8(%rsp) movl $0xffffffff, %ebp # imm = 0xFFFFFFFF xorl %edx, %edx movl $0xffffffff, %r14d # imm = 0xFFFFFFFF movq %r13, 0x50(%rsp) movq %rcx, 0x18(%rsp) movq (%r15), %rax cmpl $0x6, %r9d jae 0x33264e movl %eax, %r12d cmpl $-0x1, %eax je 0x332675 cmpl $-0x1, %ebp je 0x332684 cmpl $-0x1, %r14d je 0x33268c movl %edx, (%rsp) movq 0x88(%r13), %rcx movq 0xd0(%rcx), %rax testq %rax, %rax jne 0x3325d4 movl 0x40(%rsi), %eax movl %eax, 0x8(%rcx) movq 0x88(%r13), %rax movq %rax, 0x48(%rsp) movl 0x8(%rax), %r13d movq %r13, %rbx shlq $0x4, %rbx leaq 0x8(%rbx), %rdi callq 0x1a57a0 leaq 0x8(%rax), %rcx movq %r13, (%rax) testq %r13, %r13 je 0x3325b5 addq %rcx, %rbx movq %rcx, %rax movl $0x0, (%rax) movq $0x0, 0x8(%rax) addq $0x10, %rax cmpq %rbx, %rax jne 0x33259e movq 0x48(%rsp), %rax movq %rcx, 0xd0(%rax) movq 0x50(%rsp), %r13 movq 0x88(%r13), %rax movq 0xd0(%rax), %rax movq 0x8(%rsp), %rbx shlq $0x4, %rbx movl $0x3, (%rax,%rbx) movl $0xc, %edi callq 0x1a57a0 movq 0x88(%r13), %rcx movq 0xd0(%rcx), %rcx movq %rax, 0x8(%rcx,%rbx) movq 0x88(%r13), %rax movq 0xd0(%rax), %rax movq 0x8(%rax,%rbx), %rax movl %ebp, (%rax) movq 0x88(%r13), %rax movq 0xd0(%rax), %rax movq 0x8(%rax,%rbx), %rax movl %r14d, 0x4(%rax) movq 0x88(%r13), %rax movq 0xd0(%rax), %rax movq 0x8(%rax,%rbx), %rax movl %r12d, 0x8(%rax) testb $0x1, (%rsp) je 0x332694 xorl %edx, %edx jmp 0x3326b6 cmpl $0x7, %r9d je 0x3326e1 movl $0x0, %r12d cmpl $0x6, %r9d jne 0x33253d movd %eax, %xmm0 cvttss2si %xmm0, %eax jmp 0x332531 movl $0xffffffff, %eax # imm = 0xFFFFFFFF xorl %edx, %edx movl $0xffffffff, %r14d # imm = 0xFFFFFFFF jmp 0x3326c8 movl %r14d, %eax movl %r12d, %r14d jmp 0x3326c8 movl %r12d, %eax movl %ebp, %r14d jmp 0x3326c8 movq 0x88(%r13), %rax movq 0xd0(%rax), %rax movq 0x8(%rax,%rbx), %rax movq (%rax), %xmm0 pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3] movq %xmm0, (%rax) movb $0x1, %dl movl %r12d, %eax movl 0x20(%rsp), %r9d movq 0x10(%rsp), %rsi movq 0x18(%rsp), %rcx addq $0x8, %r15 movl %r14d, %ebp movl %eax, %r14d cmpq 0x8(%rcx), %r15 jne 0x332524 jmp 0x332a20 movq %rax, %xmm0 cvttsd2si %xmm0, %eax jmp 0x332531 cmpl $-0x1, %r12d je 0x332819 movq (%r15), %rax movq 0x8(%r15), %rcx movslq %r12d, %rdx subq %rax, %rcx sarq $0x3, %rcx imulq %r11, %rcx cmpq %rdx, %rcx jbe 0x332b2d leaq (%rdx,%rdx,2), %rsi movq 0x8(%rax,%rsi,8), %rcx movq %rsi, 0x10(%rsp) subq (%rax,%rsi,8), %rcx movq %rcx, %r12 shrq $0x3, %r12 movq 0x88(%r13), %rax movq 0xd0(%rax), %rax movl %ebp, 0x8(%rsp) movl %ebp, %r14d shlq $0x4, %r14 movl %r12d, (%rax,%r14) shrq %rcx movabsq $0x3fffffffc, %rdi # imm = 0x3FFFFFFFC andq %rcx, %rdi movq %rdx, %rbp callq 0x1a57a0 movq 0x88(%r13), %rcx movq 0xd0(%rcx), %rcx movq %rax, 0x8(%rcx,%r14) movq (%r15), %rax movq 0x8(%r15), %rcx subq %rax, %rcx sarq $0x3, %rcx movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB imulq %rdx, %rcx cmpq %rbp, %rcx jbe 0x332b8d movq %rdx, %r11 testl %r12d, %r12d movl 0x20(%rsp), %r10d movl 0x8(%rsp), %ebp je 0x332819 movq 0x10(%rsp), %rcx movq (%rax,%rcx,8), %rax movl %r12d, %ecx xorl %edx, %edx movl %r10d, %esi leaq 0x274aba(%rip), %rdi # 0x5a7280 movl $0x0, %r8d cmpl $0x7, %r10d ja 0x3327e0 movq (%rax,%rdx,8), %r8 movslq (%rdi,%rsi,4), %r9 addq %rdi, %r9 jmpq *%r9 movq 0x88(%r13), %r9 movq 0xd0(%r9), %r9 movq 0x8(%r9,%r14), %r9 movl %r8d, (%r9,%rdx,4) incq %rdx cmpq %rdx, %rcx jne 0x3327c6 jmp 0x332819 movq %r8, %xmm0 cvttsd2si %xmm0, %r8 jmp 0x3327e0 movd %r8d, %xmm0 cvttss2si %xmm0, %r8 jmp 0x3327e0 cmpl $-0x1, (%rsp) je 0x332a20 movq (%r15), %rax movq 0x8(%r15), %rdx movslq (%rsp), %rcx subq %rax, %rdx sarq $0x3, %rdx imulq %r11, %rdx cmpq %rcx, %rdx jbe 0x332bed leaq (%rcx,%rcx,2), %rcx movq (%rax,%rcx,8), %rsi movq 0x8(%rax,%rcx,8), %rdi subq %rsi, %rdi shrq $0x3, %rdi leal -0x6(%rdi), %eax cmpl $0x2, %eax ja 0x332a20 movl %ebp, %r8d xorl %r12d, %r12d shlq $0x4, %r8 movl %ebx, %r9d movq %r13, 0x50(%rsp) movl %ebx, 0x18(%rsp) movq %rsi, (%rsp) movq %rdi, 0x20(%rsp) movq %r8, 0x10(%rsp) movq %r9, 0x8(%rsp) movq 0x88(%r13), %rax movq 0xd0(%rax), %rcx movq 0x8(%rcx,%r8), %rcx movl %r12d, %edx shrl %edx movl (%rcx,%rdx,4), %ebp cmpl 0x4(%rax), %ebp jae 0x332a14 cmpq $0x0, 0x70(%rax) jne 0x332935 movl $0x2, 0xb0(%rax) movq 0x88(%r13), %r13 movl 0x4(%r13), %ebx leaq (,%rbx,4), %rax leaq (%rax,%rax,2), %r15 movq %r15, %rdi callq 0x1a57a0 movq %rax, %r14 testq %rbx, %rbx je 0x332915 addq $-0xc, %r15 movq %r15, %rax movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB mulq %rcx shrq $0x3, %rdx leaq (%rdx,%rdx,2), %rax leaq 0xc(,%rax,4), %rdx movq %r14, %rdi xorl %esi, %esi callq 0x1a54e0 movq %r14, 0x70(%r13) movq 0x50(%rsp), %r13 movl 0x18(%rsp), %ebx movq (%rsp), %rsi movq 0x20(%rsp), %rdi movq 0x10(%rsp), %r8 movq 0x8(%rsp), %r9 movq (%rsi,%r12,8), %rax testb $0x1, %r12b jne 0x33295d cmpl $0x7, %ebx ja 0x3329b5 leaq 0x274975(%rip), %rdx # 0x5a72c0 movslq (%rdx,%r9,4), %rcx addq %rdx, %rcx jmpq *%rcx xorps %xmm0, %xmm0 cvtsi2ss %eax, %xmm0 jmp 0x3329b9 cmpl $0x7, %ebx ja 0x3329d6 leaq 0x274937(%rip), %rdx # 0x5a72a0 movslq (%rdx,%r9,4), %rcx addq %rdx, %rcx jmpq *%rcx xorps %xmm0, %xmm0 cvtsi2ss %eax, %xmm0 jmp 0x3329da movl %eax, %eax xorps %xmm0, %xmm0 cvtsi2ss %rax, %xmm0 jmp 0x3329b9 movl %eax, %eax xorps %xmm0, %xmm0 cvtsi2ss %rax, %xmm0 jmp 0x3329da movq %rax, %xmm0 cvtsd2ss %xmm0, %xmm0 jmp 0x3329b9 movq %rax, %xmm0 cvtsd2ss %xmm0, %xmm0 jmp 0x3329da movd %eax, %xmm0 jmp 0x3329b9 movd %eax, %xmm0 jmp 0x3329da xorpd %xmm0, %xmm0 movq 0x88(%r13), %rax movq 0x70(%rax), %rax leaq (,%rbp,2), %rcx addq %rbp, %rcx movss %xmm0, (%rax,%rcx,4) jmp 0x3329f6 xorpd %xmm0, %xmm0 movq 0x88(%r13), %rax movq 0x70(%rax), %rax leaq (,%rbp,2), %rcx addq %rbp, %rcx movss %xmm0, 0x4(%rax,%rcx,4) movq 0x88(%r13), %rax movq 0x70(%rax), %rax leaq (,%rbp,2), %rcx addq %rbp, %rcx movl $0x0, 0x8(%rax,%rcx,4) incq %r12 cmpl %r12d, %edi jne 0x33288b addq $0x58, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x2749ea(%rip), %rdi # 0x5a7420 leaq 0x2749f8(%rip), %rsi # 0x5a7435 leaq 0x274ae1(%rip), %rcx # 0x5a7525 movl $0x1fd, %edx # imm = 0x1FD callq 0x1a5270 leaq 0x274ab9(%rip), %rdi # 0x5a750e leaq 0x2749d9(%rip), %rsi # 0x5a7435 leaq 0x274ac2(%rip), %rcx # 0x5a7525 movl $0x1fe, %edx # imm = 0x1FE callq 0x1a5270 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x38(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x274b00(%rip), %rsi # 0x5a758a leaq 0x274b34(%rip), %rdx # 0x5a75c5 leaq 0x28(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3aac86(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3aac52(%rip), %rsi # 0x6dd710 movq 0x47949b(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x38(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x274c11(%rip), %rsi # 0x5a76fb leaq 0x274c3c(%rip), %rdx # 0x5a772d leaq 0x28(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3aac26(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3aabf2(%rip), %rsi # 0x6dd710 movq 0x47943b(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x38(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x274bb1(%rip), %rsi # 0x5a76fb leaq 0x274bdc(%rip), %rdx # 0x5a772d leaq 0x28(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3aabc6(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3aab92(%rip), %rsi # 0x6dd710 movq 0x4793db(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x38(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x274b51(%rip), %rsi # 0x5a76fb leaq 0x274b7c(%rip), %rdx # 0x5a772d leaq 0x28(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3aab66(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3aab32(%rip), %rsi # 0x6dd710 movq 0x47937b(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x38(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x274af1(%rip), %rsi # 0x5a76fb leaq 0x274b1c(%rip), %rdx # 0x5a772d leaq 0x28(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x28(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3aab06(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3aaad2(%rip), %rsi # 0x6dd710 movq 0x47931b(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 jmp 0x332c5d jmp 0x332c7e jmp 0x332c5d jmp 0x332c7e jmp 0x332c5d jmp 0x332c7e jmp 0x332c5d jmp 0x332c7e movq %rax, %r14 movq 0x28(%rsp), %rdi cmpq %r15, %rdi je 0x332c77 movq 0x38(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x332c81 jmp 0x332c89 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/Ply/PlyLoader.cpp
Assimp::PLY::ElementInstance::ParseInstanceBinary(Assimp::IOStreamBuffer<char>&, std::vector<char, std::allocator<char>>&, char const*&, unsigned int&, Assimp::PLY::Element const*, Assimp::PLY::ElementInstance*, bool)
bool PLY::ElementInstance::ParseInstanceBinary( IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, const char* &pCur, unsigned int &bufferSize, const PLY::Element* pcElement, PLY::ElementInstance* p_pcOut, bool p_bBE /* = false */) { ai_assert(NULL != pcElement); ai_assert(NULL != p_pcOut); // allocate enough storage p_pcOut->alProperties.resize(pcElement->alProperties.size()); std::vector<PLY::PropertyInstance>::iterator i = p_pcOut->alProperties.begin(); std::vector<PLY::Property>::const_iterator a = pcElement->alProperties.begin(); for (; i != p_pcOut->alProperties.end(); ++i, ++a) { if (!(PLY::PropertyInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, &(*a), &(*i), p_bBE))) { ASSIMP_LOG_WARN("Unable to parse binary property instance. " "Skipping this element instance"); (*i).avList.push_back(PLY::PropertyInstance::DefaultValue((*a).eType)); } } return true; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp testq %r8, %r8 je 0x334d48 movq %r9, %r14 movq %rdi, 0x18(%rsp) testq %r9, %r9 je 0x334d67 movq %rsi, %rbx movq %rdx, %r13 movq %rcx, %r12 movq 0x8(%r8), %rax subq (%r8), %rax sarq $0x4, %rax movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB imulq %rax, %rsi movq %r14, %rdi movq %r8, %r15 callq 0x3359d2 movq (%r14), %rbp cmpq 0x8(%r14), %rbp movq 0x18(%rsp), %rdx je 0x334d37 movq %r12, %rax movq %r13, %r12 movq %rbx, %r13 movq %r14, %rcx movq (%r15), %r14 movzbl 0x60(%rsp), %esi movl %esi, 0x14(%rsp) movq %rcx, 0x20(%rsp) movl 0x14(%rsp), %ecx movl %ecx, (%rsp) movq %rdx, %r15 movq %rdx, %rdi movq %r13, %rsi movq %r12, %rdx movq %rax, %rbx movq %rax, %rcx movq %r14, %r8 movq %rbp, %r9 callq 0x334f68 movq %r15, %rdx movq 0x20(%rsp), %rcx movq %rbx, %rax addq $0x18, %rbp addq $0x30, %r14 cmpq 0x8(%rcx), %rbp jne 0x334cfa movb $0x1, %al addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x27318e(%rip), %rdi # 0x5a7edd leaq 0x272aba(%rip), %rsi # 0x5a7810 leaq 0x2733d2(%rip), %rcx # 0x5a812f movl $0x32a, %edx # imm = 0x32A callq 0x1a5270 leaq 0x272ff8(%rip), %rdi # 0x5a7d66 leaq 0x272a9b(%rip), %rsi # 0x5a7810 leaq 0x2733b3(%rip), %rcx # 0x5a812f movl $0x32b, %edx # imm = 0x32B callq 0x1a5270
/hbina[P]fatuous/thirdparty/assimp/code/Ply/PlyParser.cpp
Assimp::PLY::PropertyInstance::ParseValueBinary(Assimp::IOStreamBuffer<char>&, std::vector<char, std::allocator<char>>&, char const*&, unsigned int&, Assimp::PLY::EDataType, Assimp::PLY::PropertyInstance::ValueUnion*, bool)
bool PLY::PropertyInstance::ParseValueBinary(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, const char* &pCur, unsigned int &bufferSize, PLY::EDataType eType, PLY::PropertyInstance::ValueUnion* out, bool p_bBE) { ai_assert(NULL != out); //calc element size unsigned int lsize = 0; switch (eType) { case EDT_Char: case EDT_UChar: lsize = 1; break; case EDT_UShort: case EDT_Short: lsize = 2; break; case EDT_UInt: case EDT_Int: case EDT_Float: lsize = 4; break; case EDT_Double: lsize = 8; break; case EDT_INVALID: default: break; } //read the next file block if needed if (bufferSize < lsize) { std::vector<char> nbuffer; if (streamBuffer.getNextBlock(nbuffer)) { //concat buffer contents buffer = std::vector<char>(buffer.end() - bufferSize, buffer.end()); buffer.insert(buffer.end(), nbuffer.begin(), nbuffer.end()); nbuffer.clear(); bufferSize = static_cast<unsigned int>(buffer.size()); pCur = (char*)&buffer[0]; } else { throw DeadlyImportError("Invalid .ply file: File corrupted"); } } bool ret = true; switch (eType) { case EDT_UInt: { uint32_t t; memcpy(&t, pCur, sizeof(uint32_t)); pCur += sizeof(uint32_t); // Swap endianness if (p_bBE)ByteSwap::Swap(&t); out->iUInt = t; break; } case EDT_UShort: { uint16_t t; memcpy(&t, pCur, sizeof(uint16_t)); pCur += sizeof(uint16_t); // Swap endianness if (p_bBE)ByteSwap::Swap(&t); out->iUInt = t; break; } case EDT_UChar: { uint8_t t; memcpy(&t, pCur, sizeof(uint8_t)); pCur += sizeof(uint8_t); out->iUInt = t; break; } case EDT_Int: { int32_t t; memcpy(&t, pCur, sizeof(int32_t)); pCur += sizeof(int32_t); // Swap endianness if (p_bBE)ByteSwap::Swap(&t); out->iInt = t; break; } case EDT_Short: { int16_t t; memcpy(&t, pCur, sizeof(int16_t)); pCur += sizeof(int16_t); // Swap endianness if (p_bBE)ByteSwap::Swap(&t); out->iInt = t; break; } case EDT_Char: { int8_t t; memcpy(&t, pCur, sizeof(int8_t)); pCur += sizeof(int8_t); out->iInt = t; break; } case EDT_Float: { float t; memcpy(&t, pCur, sizeof(float)); pCur += sizeof(float); // Swap endianness if (p_bBE)ByteSwap::Swap(&t); out->fFloat = t; break; } case EDT_Double: { double t; memcpy(&t, pCur, sizeof(double)); pCur += sizeof(double); // Swap endianness if (p_bBE)ByteSwap::Swap(&t); out->fDouble = t; break; } default: ret = false; } bufferSize -= lsize; return ret; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x48, %rsp movq %r9, %r14 testq %r9, %r9 je 0x3354fd movl %r8d, %ebp movq %rcx, %r9 movq %rdx, %r15 xorl %r13d, %r13d movl %r8d, %ebx cmpl $0x7, %r8d ja 0x3353cf leaq 0x2731d6(%rip), %rax # 0x5a84a4 movl (%rax,%rbx,4), %r13d cmpl %r13d, (%r9) jae 0x3353cf movq %rsi, %r12 movq %r9, 0x8(%rsp) xorps %xmm0, %xmm0 leaq 0x30(%rsp), %rsi movaps %xmm0, (%rsi) movq $0x0, 0x10(%rsi) callq 0x335886 testb %al, %al movq 0x8(%rsp), %rax je 0x33551c movq 0x8(%r12), %rdx movl (%rax), %eax movq %rdx, %rsi subq %rax, %rsi leaq 0x10(%rsp), %rdi leaq 0x7(%rsp), %rcx callq 0x335d78 movq (%r12), %rdi movq 0x10(%r12), %rsi movaps 0x10(%rsp), %xmm0 movups %xmm0, (%r12) movq 0x20(%rsp), %rax movq %rax, 0x10(%r12) xorps %xmm0, %xmm0 movaps %xmm0, 0x10(%rsp) movq $0x0, 0x20(%rsp) testq %rdi, %rdi je 0x335376 subq %rdi, %rsi callq 0x1a5190 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x335376 movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x8(%r12), %rsi movq 0x30(%rsp), %rdx movq 0x38(%rsp), %rcx movq %r12, %rdi callq 0x336cfc movq (%r12), %rax movq 0x30(%rsp), %rdi cmpq %rdi, 0x38(%rsp) movq 0x8(%rsp), %r9 je 0x3353a7 movq %rdi, 0x38(%rsp) movl 0x8(%r12), %ecx subl %eax, %ecx movl %ecx, (%r9) movq (%r12), %rax movq %rax, (%r15) testq %rdi, %rdi je 0x3353cf movq 0x40(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x8(%rsp), %r9 cmpl $0x7, %ebp ja 0x3354f9 movb 0x80(%rsp), %al leaq 0x27237a(%rip), %rcx # 0x5a7760 movslq (%rcx,%rbx,4), %rdx addq %rcx, %rdx jmpq *%rdx movq (%r15), %rsi movl (%rsi), %edi movl %edi, %r8d shrl $0x8, %r8d movl %edi, %edx shrl $0x10, %edx movl %edi, %ecx shrl $0x18, %ecx addq $0x4, %rsi movq %rsi, (%r15) testb %al, %al je 0x335419 movzbl %dil, %esi movl %r8d, %eax jmp 0x335422 movl %ecx, %esi movl %edx, %eax movl %r8d, %edx movl %edi, %ecx shll $0x18, %esi movl $0xff, %edi andl %edi, %eax shll $0x10, %eax orl %esi, %eax shll $0x8, %edx movzwl %dx, %edx orl %eax, %edx andl %edi, %ecx orl %edx, %ecx jmp 0x3354e2 movq (%r15), %rcx movzwl (%rcx), %edx movl %edx, %esi shrl $0x8, %esi addq $0x2, %rcx movq %rcx, (%r15) testb %al, %al movl %esi, %eax cmovnel %edx, %eax cmovel %edx, %esi shll $0x8, %eax movzbl %sil, %ecx orl %eax, %ecx movswl %cx, %eax jmp 0x3354b2 movq (%r15), %rcx movq (%rcx), %rdx addq $0x8, %rcx movq %rcx, (%r15) movq %rdx, %rcx bswapq %rcx testb %al, %al cmoveq %rdx, %rcx movq %rcx, (%r14) jmp 0x3354e5 movq (%r15), %rcx movzwl (%rcx), %edx movl %edx, %esi shrl $0x8, %esi addq $0x2, %rcx movq %rcx, (%r15) testb %al, %al movl %esi, %eax cmovnel %edx, %eax cmovel %edx, %esi shll $0x8, %eax movzbl %sil, %ecx orl %eax, %ecx movzwl %cx, %eax movl %eax, (%r14) jmp 0x3354e5 movq (%r15), %rax movsbl (%rax), %ecx jmp 0x3354c5 movq (%r15), %rax movzbl (%rax), %ecx incq %rax movq %rax, (%r15) jmp 0x3354e2 movq (%r15), %rcx movl (%rcx), %edx addq $0x4, %rcx movq %rcx, (%r15) movl %edx, %ecx bswapl %ecx testb %al, %al cmovel %edx, %ecx movl %ecx, (%r14) movb $0x1, %al subl %r13d, (%r9) addq $0x48, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq xorl %eax, %eax jmp 0x3354e7 leaq 0x2a693a(%rip), %rdi # 0x5dbe3e leaq 0x272305(%rip), %rsi # 0x5a7810 leaq 0x272eac(%rip), %rcx # 0x5a83be movl $0x3e0, %edx # imm = 0x3E0 callq 0x1a5270 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x20(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x272f48(%rip), %rsi # 0x5a8481 leaq 0x272f62(%rip), %rdx # 0x5a84a2 leaq 0x10(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3a81d7(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3a81a3(%rip), %rsi # 0x6dd710 movq 0x4769ec(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x10(%rsp), %rdi cmpq %r15, %rdi je 0x335596 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x3355a0 jmp 0x3355b1 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 jmp 0x3355b1 jmp 0x3355ae jmp 0x3355ae movq %rax, %r14 movq 0x30(%rsp), %rdi testq %rdi, %rdi je 0x3355c8 movq 0x40(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Ply/PlyParser.cpp
Assimp::IOStreamBuffer<char>::getNextBlock(std::vector<char, std::allocator<char>>&)
AI_FORCE_INLINE bool IOStreamBuffer<T>::getNextBlock( std::vector<T> &buffer) { // Return the last block-value if getNextLine was used before if ( 0 != m_cachePos ) { buffer = std::vector<T>( m_cache.begin() + m_cachePos, m_cache.end() ); m_cachePos = 0; } else { if ( !readNextBlock() ) { return false; } buffer = std::vector<T>(m_cache.begin(), m_cache.end()); } return true; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %r14 movq %rdi, %rbx movq 0x40(%rdi), %rsi testq %rsi, %rsi je 0x33591b addq 0x28(%rbx), %rsi movq 0x30(%rbx), %rdx leaq 0x10(%rsp), %r15 leaq 0xf(%rsp), %rcx movq %r15, %rdi callq 0x335d78 movq (%r14), %rdi movq 0x10(%r14), %rsi movaps (%r15), %xmm0 movups %xmm0, (%r14) movq 0x10(%r15), %rax movq %rax, 0x10(%r14) xorps %xmm0, %xmm0 movaps %xmm0, (%r15) movq $0x0, 0x10(%r15) testq %rdi, %rdi je 0x335903 subq %rdi, %rsi callq 0x1a5190 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x335903 movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq $0x0, 0x40(%rbx) movb $0x1, %bpl movl %ebp, %eax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq (%rbx), %rdi movq 0x48(%rbx), %rsi movq (%rdi), %rax xorl %ebp, %ebp xorl %edx, %edx callq *0x20(%rax) movq 0x28(%rbx), %rsi movq (%rbx), %rdi movq 0x10(%rbx), %rcx movq (%rdi), %rax movl $0x1, %edx callq *0x10(%rax) testq %rax, %rax je 0x33590e movq 0x10(%rbx), %rcx cmpq %rcx, %rax jae 0x335957 movq %rax, 0x10(%rbx) movq %rax, %rcx addq %rcx, 0x48(%rbx) xorl %r15d, %r15d movq %r15, 0x40(%rbx) incq 0x20(%rbx) movq 0x28(%rbx), %rsi movq 0x30(%rbx), %rdx leaq 0x10(%rsp), %rbx leaq 0xf(%rsp), %rcx movq %rbx, %rdi callq 0x335d78 movq (%r14), %rdi movq 0x10(%r14), %rsi movaps (%rbx), %xmm0 movups %xmm0, (%r14) movq 0x10(%rbx), %rax movq %rax, 0x10(%r14) movq %r15, 0x10(%rbx) xorps %xmm0, %xmm0 movaps %xmm0, (%rbx) testq %rdi, %rdi je 0x33590b subq %rdi, %rsi callq 0x1a5190 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x33590b movq 0x20(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 jmp 0x33590b nop
/hbina[P]fatuous/thirdparty/assimp/include/assimp/IOStreamBuffer.h
Assimp::MS3DImporter::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const
bool MS3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const { // first call - simple extension check const std::string extension = GetExtension(pFile); if (extension == "ms3d") { return true; } // second call - check for magic identifiers else if (!extension.length() || checkSig) { if (!pIOHandler) { return true; } const char* tokens[] = {"MS3D000000"}; return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1); } return false; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x38, %rsp movl %ecx, %ebp movq %rdx, %r15 movq %rsi, %r14 leaq 0x10(%rsp), %rbx movq %rbx, %rdi callq 0x24818a leaq 0x27157e(%rip), %rsi # 0x5a84c4 movq %rbx, %rdi callq 0x1a60c0 movb $0x1, %bl testl %eax, %eax je 0x336fa0 cmpq $0x0, 0x18(%rsp) setne %al xorb $0x1, %bpl testb %bpl, %al jne 0x336f9e testq %r15, %r15 je 0x336fa0 leaq 0x271557(%rip), %rax # 0x5a84c9 leaq 0x30(%rsp), %rdx movq %rax, (%rdx) movl $0x0, (%rsp) movq %r15, %rdi movq %r14, %rsi movl $0x1, %ecx movl $0xc8, %r8d xorl %r9d, %r9d callq 0x247ca8 movl %eax, %ebx jmp 0x336fa0 xorl %ebx, %ebx leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x336fbb movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movl %ebx, %eax addq $0x38, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x336fe6 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/MS3D/MS3DLoader.cpp
Assimp::COBImporter::ThrowException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
AI_WONT_RETURN void COBImporter::ThrowException(const std::string& msg) { throw DeadlyImportError("COB: "+msg); }
pushq %rbp pushq %r14 pushq %rbx subq $0x20, %rsp movq %rdi, %r14 movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x26d116(%rip), %rsi # 0x5a88d5 movq %rsp, %rdi movq %r14, %rdx callq 0x23ca59 movb $0x1, %bpl movq %rsp, %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x3a1f59(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3a1f25(%rip), %rsi # 0x6dd710 movq 0x47076e(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 leaq 0x10(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x33b818 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x33b822 jmp 0x33b82a movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/COB/COBLoader.cpp
Assimp::COBImporter::ReadBone_Ascii(Assimp::COB::Scene&, Assimp::LineSplitter&, Assimp::COB::ChunkInfo const&)
void COBImporter::ReadBone_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo) { if(nfo.version > 5) { return UnsupportedChunk_Ascii(splitter,nfo,"Bone"); } out.nodes.push_back(std::shared_ptr<Bone>(new Bone())); Bone& msh = (Bone&)(*out.nodes.back().get()); msh = nfo; ReadBasicNodeInfo_Ascii(msh,++splitter,nfo); // TODO }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x20, %rsp movq %rcx, %r14 movq %rdx, %rbx cmpl $0x6, 0x8(%rcx) jb 0x33f804 leaq 0x259bb6(%rip), %rcx # 0x5993a2 movq %rbx, %rsi movq %r14, %rdx addq $0x20, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 jmp 0x33fc68 movq %rsi, %r15 movl $0xd8, %edi callq 0x1a5230 movq %rax, %r12 movq %rax, %rdi movl $0x4, %esi callq 0x341d66 leaq 0x3a0b38(%rip), %rax # 0x6e0360 movq %rax, (%r12) leaq 0x8(%rsp), %r13 movq %r12, -0x8(%r13) movq %r13, %rdi movq %r12, %rsi callq 0x343798 movaps -0x8(%r13), %xmm0 leaq 0x10(%rsp), %rsi movaps %xmm0, (%rsi) xorps %xmm0, %xmm0 movaps %xmm0, -0x8(%r13) movq %r15, %rdi callq 0x343468 movq 0x18(%rsp), %rdi testq %rdi, %rdi je 0x33f86c callq 0x280464 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x33f87b callq 0x280464 movq 0x30(%r15), %rax cmpq 0x38(%r15), %rax jne 0x33f892 movq 0x48(%r15), %rcx movl $0x200, %eax # imm = 0x200 addq -0x8(%rcx), %rax movq -0x10(%rax), %r15 movups (%r14), %xmm0 movups %xmm0, 0x8(%r15) movq %rbx, %rdi callq 0x2cb430 movq %r15, %rsi movq %rax, %rdx callq 0x33fdd0 addq $0x20, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq movq %rax, %rbx movq 0x18(%rsp), %rdi testq %rdi, %rdi je 0x33f8d2 callq 0x280464 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x33f8f3 callq 0x280464 jmp 0x33f8f3 movq %rax, %rbx movl $0xd8, %esi movq %r12, %rdi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/COB/COBLoader.cpp
Assimp::COBImporter::UnsupportedChunk_Binary(Assimp::StreamReader<false, false>&, Assimp::COB::ChunkInfo const&, char const*)
void COBImporter::UnsupportedChunk_Binary( StreamReaderLE& reader, const ChunkInfo& nfo, const char* name) { const std::string error = format("Encountered unsupported chunk: ") << name << " [version: "<<nfo.version<<", size: "<<nfo.size<<"]"; // we can recover if the chunk size was specified. if(nfo.size != static_cast<unsigned int>(-1)) { ASSIMP_LOG_ERROR(error); reader.IncPtr(nfo.size); } else ThrowException(error); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rdx, %r14 movq %rsi, %rbx leaq 0x28(%rsp), %r15 movq %rcx, (%r15) leaq 0x26887c(%rip), %rsi # 0x5a8ad9 leaq 0x30(%rsp), %r12 movq %r12, %rdi callq 0x341602 movq %r12, %rdi movq %r15, %rsi callq 0x2be92a movq %rax, %r15 leaq 0x26887a(%rip), %rsi # 0x5a8af9 movl $0xb, %edx movq %rax, %rdi callq 0x1a61e0 movl 0x8(%r14), %esi movq %r15, %rdi callq 0x1a5850 leaq 0x268866(%rip), %rsi # 0x5a8b05 movl $0x8, %edx movq %r15, %rdi callq 0x1a61e0 movl 0xc(%r14), %esi movq %r15, %rdi callq 0x1a5850 leaq 0x251cbd(%rip), %rsi # 0x591f7c movl $0x1, %edx movq %r15, %rdi callq 0x1a61e0 addq $0x8, %r15 leaq 0x8(%rsp), %rdi movq %r15, %rsi callq 0x1a5690 movq 0x46bcac(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 cmpl $-0x1, 0xc(%r14) je 0x34034a callq 0x241234 movq 0x8(%rsp), %rsi movq %rax, %rdi callq 0x2411ba movl 0xc(%r14), %esi movq %rbx, %rdi callq 0x27f688 leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x34033b movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x1a8, %rsp # imm = 0x1A8 popq %rbx popq %r12 popq %r14 popq %r15 retq leaq 0x8(%rsp), %rdi callq 0x33b7a0 movq %rax, %rbx leaq 0x18(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x340395 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x340395 movq %rax, %rbx movq 0x46bc12(%rip), %rsi # 0x7abf90 leaq 0x30(%rsp), %rdi callq 0x1a5d00 leaq 0xa0(%rsp), %rdi callq 0x1a5ca0 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/COB/COBLoader.cpp
Assimp::COBImporter::ReadPolH_Binary(Assimp::COB::Scene&, Assimp::StreamReader<false, false>&, Assimp::COB::ChunkInfo const&)
void COBImporter::ReadPolH_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo) { if(nfo.version > 8) { return UnsupportedChunk_Binary(reader,nfo,"PolH"); } const chunk_guard cn(nfo,reader); out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh())); Mesh& msh = (Mesh&)(*out.nodes.back().get()); msh = nfo; ReadBasicNodeInfo_Binary(msh,reader,nfo); msh.vertex_positions.resize(reader.GetI4()); for(aiVector3D& v : msh.vertex_positions) { v.x = reader.GetF4(); v.y = reader.GetF4(); v.z = reader.GetF4(); } msh.texture_coords.resize(reader.GetI4()); for(aiVector2D& v : msh.texture_coords) { v.x = reader.GetF4(); v.y = reader.GetF4(); } const size_t numf = reader.GetI4(); msh.faces.reserve(numf); for(size_t i = 0; i < numf; ++i) { // XXX backface culling flag is 0x10 in flags // hole? bool hole; if ((hole = (reader.GetI1() & 0x08) != 0)) { // XXX Basically this should just work fine - then triangulator // should output properly triangulated data even for polygons // with holes. Test data specific to COB is needed to confirm it. if (msh.faces.empty()) { ThrowException(format("A hole is the first entity in the `PolH` chunk with id ") << nfo.id); } } else msh.faces.push_back(Face()); Face& f = msh.faces.back(); const size_t num = reader.GetI2(); f.indices.reserve(f.indices.size() + num); if(!hole) { f.material = reader.GetI2(); f.flags = 0; } for(size_t x = 0; x < num; ++x) { f.indices.push_back(VertexIndex()); VertexIndex& v = f.indices.back(); v.pos_idx = reader.GetI4(); v.uv_idx = reader.GetI4(); } if(hole) { std::reverse(f.indices.rbegin(),f.indices.rbegin()+num); } } if (nfo.version>4) { msh.draw_flags = reader.GetI4(); } nfo.version>5 && nfo.version<8 ? reader.GetI4() : 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x1e8, %rsp # imm = 0x1E8 movq %rcx, %rax movq %rdx, %r14 cmpl $0x9, 0x8(%rcx) jb 0x3403de leaq 0x2689bb(%rip), %rcx # 0x5a8d7d movq %r14, %rsi movq %rax, %rdx addq $0x1e8, %rsp # imm = 0x1E8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp jmp 0x34023a movq %rsi, %rbx movq %rax, 0x10(%rsp) movq %rax, 0x58(%rsp) movq %r14, 0x60(%rsp) movl 0x18(%r14), %eax subl 0x10(%r14), %eax cltq movq %rax, 0x68(%rsp) movl $0x158, %edi # imm = 0x158 callq 0x1a5230 movq %rax, %r15 movq %rax, %rdi xorl %esi, %esi callq 0x341d66 leaq 0x39ff7b(%rip), %rax # 0x6e0398 movq %rax, (%r15) xorps %xmm0, %xmm0 movups %xmm0, 0xd8(%r15) movups %xmm0, 0xe8(%r15) movups %xmm0, 0xf8(%r15) movups %xmm0, 0x108(%r15) xorl %eax, %eax movq %rax, 0x118(%r15) movl $0x1, 0x120(%r15) movq %r15, %rcx addq $0x130, %rcx # imm = 0x130 movl $0x0, 0x130(%r15) movq %rax, 0x138(%r15) movq %rcx, 0x140(%r15) movq %rcx, 0x148(%r15) movq %rax, 0x150(%r15) leaq 0x28(%rsp), %rdi movq %r15, -0x8(%rdi) movq %r15, %rsi callq 0x3438d4 movaps 0x20(%rsp), %xmm0 leaq 0x70(%rsp), %rsi movaps %xmm0, (%rsi) xorps %xmm0, %xmm0 movaps %xmm0, 0x20(%rsp) movq %rbx, %rdi callq 0x343468 movq 0x78(%rsp), %rdi testq %rdi, %rdi movq 0x10(%rsp), %r15 je 0x3404ca callq 0x280464 movq 0x28(%rsp), %rdi testq %rdi, %rdi je 0x3404d9 callq 0x280464 movq 0x30(%rbx), %rax cmpq 0x38(%rbx), %rax jne 0x3404f0 movq 0x48(%rbx), %rcx movl $0x200, %eax # imm = 0x200 addq -0x8(%rcx), %rax movq -0x10(%rax), %rbx movups (%r15), %xmm0 movups %xmm0, 0x8(%rbx) movq %rbx, %rsi movq %r14, %rdx callq 0x340086 movq %r14, %rdi callq 0x28094c leaq 0xf0(%rbx), %rdi movslq %eax, %rsi callq 0x27a25a movq %rbx, %rax movq 0xf0(%rbx), %rbx movq %rax, 0x8(%rsp) movq 0xf8(%rax), %r15 cmpq %r15, %rbx je 0x340565 movq %r14, %rdi callq 0x2811f2 movss %xmm0, (%rbx) movq %r14, %rdi callq 0x2811f2 movss %xmm0, 0x4(%rbx) movq %r14, %rdi callq 0x2811f2 movss %xmm0, 0x8(%rbx) addq $0xc, %rbx jmp 0x340534 movq %r14, %rdi callq 0x28094c movq 0x8(%rsp), %rbx leaq 0xd8(%rbx), %rdi movslq %eax, %rsi callq 0x34178c movq %rbx, %rax movq 0xd8(%rbx), %rbx movq 0xe0(%rax), %r15 cmpq %r15, %rbx je 0x3405b6 movq %r14, %rdi callq 0x2811f2 movss %xmm0, (%rbx) movq %r14, %rdi callq 0x2811f2 movss %xmm0, 0x4(%rbx) addq $0x8, %rbx jmp 0x340592 movq %r14, %rdi callq 0x28094c movq 0x10(%rsp), %r15 movl %eax, %ebx movslq %eax, %rsi movq 0x8(%rsp), %rax leaq 0x108(%rax), %rdi movq %rdi, 0x48(%rsp) movq %rsi, 0x50(%rsp) callq 0x3417be testl %ebx, %ebx movq 0x8(%rsp), %rbx je 0x34075f movq $0x0, 0x18(%rsp) movq %r14, %rdi callq 0x280a0a testb $0x8, %al movb %al, 0x5(%rsp) jne 0x34064b xorps %xmm0, %xmm0 movaps %xmm0, 0x80(%rsp) movaps %xmm0, 0x70(%rsp) movq 0x48(%rsp), %rdi leaq 0x70(%rsp), %rsi callq 0x343a84 movq 0x78(%rsp), %rdi testq %rdi, %rdi je 0x340642 movq 0x88(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 movq 0x110(%rbx), %r15 jmp 0x34065f movq 0x110(%rbx), %r15 cmpq %r15, 0x108(%rbx) je 0x3407ab movq %r14, %rdi callq 0x28088e movl %eax, %ebx movswq %ax, %rbp leaq -0x18(%r15), %r12 movq -0x10(%r15), %rsi subq -0x18(%r15), %rsi sarq $0x3, %rsi addq %rbp, %rsi movq %r12, %rdi callq 0x3418c2 testb $0x8, 0x5(%rsp) jne 0x3406a4 movq %r14, %rdi callq 0x28088e cwtl movl %eax, -0x20(%r15) movl $0x0, -0x1c(%r15) movl %ebx, %eax movq %rbp, %rbx movw %ax, 0x6(%rsp) testw %ax, %ax je 0x3406ea movq $0x0, 0x70(%rsp) movq %r12, %rdi leaq 0x70(%rsp), %rsi callq 0x343f32 movq -0x10(%r15), %r13 movq %r14, %rdi callq 0x28094c movl %eax, -0x8(%r13) movq %r14, %rdi callq 0x28094c movl %eax, -0x4(%r13) decq %rbx jne 0x3406b3 testb $0x8, 0x5(%rsp) je 0x34073d cmpw $0x0, 0x6(%rsp) je 0x34073d movq -0x10(%r15), %rax shlq $0x3, %rbp movq %rbp, %rcx negq %rcx addq %rax, %rcx addq $0x8, %rcx cmpq %rax, %rcx jae 0x34073d movq %rax, %rcx subq %rbp, %rcx addq $0x10, %rcx movq -0x8(%rax), %rdx movq -0x10(%rcx), %rsi movq %rsi, -0x8(%rax) addq $-0x8, %rax movq %rdx, -0x10(%rcx) leaq 0x8(%rcx), %rdx cmpq %rax, %rcx movq %rdx, %rcx jb 0x34071d movq 0x18(%rsp), %rcx incq %rcx movq %rcx, 0x18(%rsp) cmpq 0x50(%rsp), %rcx movq 0x10(%rsp), %r15 movq 0x8(%rsp), %rbx jne 0x3405f9 movl 0x8(%r15), %eax cmpl $0x4, %eax jbe 0x34077f movq %r14, %rdi callq 0x28094c movq 0x8(%rsp), %rcx movl %eax, 0x120(%rcx) movl 0x8(%r15), %eax andl $-0x2, %eax cmpl $0x6, %eax jne 0x34078f movq %r14, %rdi callq 0x28094c leaq 0x58(%rsp), %rdi callq 0x34195e addq $0x1e8, %rsp # imm = 0x1E8 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x2686cd(%rip), %rsi # 0x5a8e7f leaq 0x70(%rsp), %rdi callq 0x23c974 movq 0x10(%rsp), %rax movl (%rax), %esi leaq 0x70(%rsp), %rdi callq 0x1a5850 leaq 0x78(%rsp), %rsi leaq 0x20(%rsp), %rdi callq 0x1a5690 leaq 0x20(%rsp), %rdi callq 0x33b7a0 movq %rax, %rbx movq 0x78(%rsp), %rdi testq %rdi, %rdi je 0x3407f8 callq 0x280464 movq 0x28(%rsp), %rdi testq %rdi, %rdi je 0x340894 callq 0x280464 jmp 0x340894 movq %rax, %rbx movl $0x158, %esi # imm = 0x158 movq %r15, %rdi jmp 0x340880 movq %rax, %rbx leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x340844 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x340844 jmp 0x340891 jmp 0x340891 movq %rax, %rbx movq 0x46b745(%rip), %rsi # 0x7abf90 leaq 0x70(%rsp), %rdi callq 0x1a5d00 leaq 0xe0(%rsp), %rdi callq 0x1a5ca0 jmp 0x340894 jmp 0x340891 jmp 0x340891 movq %rax, %rbx movq 0x78(%rsp), %rdi testq %rdi, %rdi je 0x340894 movq 0x88(%rsp), %rsi subq %rdi, %rsi callq 0x1a5190 jmp 0x340894 jmp 0x340891 jmp 0x340891 jmp 0x340891 jmp 0x340891 jmp 0x340891 movq %rax, %rbx leaq 0x58(%rsp), %rdi callq 0x34195e movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/COB/COBLoader.cpp
Assimp::COB::Node::~Node()
virtual ~Node() {}
pushq %rbx movq %rdi, %rbx leaq 0x39dd39(%rip), %rax # 0x6e02d0 movq %rax, (%rdi) movq 0x70(%rdi), %rdi leaq 0x80(%rbx), %rax cmpq %rax, %rdi je 0x3425b5 movq (%rax), %rsi incq %rsi callq 0x1a5190 addq $0x20, %rbx movq %rbx, %rdi popq %rbx jmp 0x341fa6
/hbina[P]fatuous/thirdparty/assimp/code/COB/COBScene.h
Assimp::BlenderImporter::ConvertBlendFile(aiScene*, Assimp::Blender::Scene const&, Assimp::Blender::FileDatabase const&)
void BlenderImporter::ConvertBlendFile(aiScene* out, const Scene& in,const FileDatabase& file) { ConversionData conv(file); // FIXME it must be possible to take the hierarchy directly from // the file. This is terrible. Here, we're first looking for // all objects which don't have parent objects at all - std::deque<const Object*> no_parents; for (std::shared_ptr<Base> cur = std::static_pointer_cast<Base> ( in.base.first ); cur; cur = cur->next) { if (cur->object) { if(!cur->object->parent) { no_parents.push_back(cur->object.get()); } else { conv.objects.insert( cur->object.get() ); } } } for (std::shared_ptr<Base> cur = in.basact; cur; cur = cur->next) { if (cur->object) { if(cur->object->parent) { conv.objects.insert(cur->object.get()); } } } if (no_parents.empty()) { ThrowException("Expected at least one object with no parent"); } aiNode* root = out->mRootNode = new aiNode("<BlenderRoot>"); root->mNumChildren = static_cast<unsigned int>(no_parents.size()); root->mChildren = new aiNode*[root->mNumChildren](); for (unsigned int i = 0; i < root->mNumChildren; ++i) { root->mChildren[i] = ConvertNode(in, no_parents[i], conv, aiMatrix4x4()); root->mChildren[i]->mParent = root; } BuildMaterials(conv); if (conv.meshes->size()) { out->mMeshes = new aiMesh*[out->mNumMeshes = static_cast<unsigned int>( conv.meshes->size() )]; std::copy(conv.meshes->begin(),conv.meshes->end(),out->mMeshes); conv.meshes.dismiss(); } if (conv.lights->size()) { out->mLights = new aiLight*[out->mNumLights = static_cast<unsigned int>( conv.lights->size() )]; std::copy(conv.lights->begin(),conv.lights->end(),out->mLights); conv.lights.dismiss(); } if (conv.cameras->size()) { out->mCameras = new aiCamera*[out->mNumCameras = static_cast<unsigned int>( conv.cameras->size() )]; std::copy(conv.cameras->begin(),conv.cameras->end(),out->mCameras); conv.cameras.dismiss(); } if (conv.materials->size()) { out->mMaterials = new aiMaterial*[out->mNumMaterials = static_cast<unsigned int>( conv.materials->size() )]; std::copy(conv.materials->begin(),conv.materials->end(),out->mMaterials); conv.materials.dismiss(); } if (conv.textures->size()) { out->mTextures = new aiTexture*[out->mNumTextures = static_cast<unsigned int>( conv.textures->size() )]; std::copy(conv.textures->begin(),conv.textures->end(),out->mTextures); conv.textures.dismiss(); } // acknowledge that the scene might come out incomplete // by Assimp's definition of `complete`: blender scenes // can consist of thousands of cameras or lights with // not a single mesh between them. if (!out->mNumMeshes) { out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x208, %rsp # imm = 0x208 movq %rdx, %r14 movq %rsi, %rbx movq %rdi, 0x50(%rsp) leaq 0xb8(%rsp), %rdi movq %rcx, %rsi callq 0x349f90 xorps %xmm0, %xmm0 leaq 0x60(%rsp), %rdi movaps %xmm0, 0x40(%rdi) movaps %xmm0, 0x30(%rdi) movaps %xmm0, 0x20(%rdi) movaps %xmm0, 0x10(%rdi) movaps %xmm0, (%rdi) xorl %esi, %esi callq 0x34ad86 movq 0x468(%r14), %rax movq %rax, 0x10(%rsp) movq 0x470(%r14), %rcx movq %rcx, 0x18(%rsp) testq %rcx, %rcx movq %rbx, (%rsp) je 0x3452bf movq 0x466cfc(%rip), %rdx # 0x7abfa8 cmpb $0x0, (%rdx) je 0x3452b6 incl 0x8(%rcx) jmp 0x3452bf lock incl 0x8(%rcx) movq 0x10(%rsp), %rax testq %rax, %rax je 0x345334 leaq 0x18(%rsp), %r12 leaq 0x60(%rsp), %r13 leaq 0x8(%rsp), %rbp leaq 0xb8(%rsp), %rbx movq 0x28(%rax), %rax testq %rax, %rax je 0x345310 cmpq $0x0, 0x4d0(%rax) je 0x345300 movq %rax, 0x8(%rsp) movq %rbx, %rdi movq %rbp, %rsi callq 0x34cbf2 jmp 0x345310 movq %rax, 0x8(%rsp) movq %r13, %rdi movq %rbp, %rsi callq 0x34c990 movq 0x10(%rsp), %rsi movq 0x18(%rsi), %rax movq %rax, 0x10(%rsp) addq $0x20, %rsi movq %r12, %rdi callq 0x34aefc movq 0x10(%rsp), %rax testq %rax, %rax jne 0x3452db movq 0x18(%rsp), %rdi testq %rdi, %rdi je 0x345343 callq 0x280464 movq 0x448(%r14), %rsi movq %rsi, 0x10(%rsp) movq 0x450(%r14), %rax movq %rax, 0x18(%rsp) testq %rax, %rax je 0x34537a movq 0x466c41(%rip), %rcx # 0x7abfa8 cmpb $0x0, (%rcx) je 0x345371 incl 0x8(%rax) jmp 0x34537a lock incl 0x8(%rax) movq 0x10(%rsp), %rsi movq (%rsp), %r15 testq %rsi, %rsi je 0x3453dc leaq 0x18(%rsp), %rbx leaq 0xb8(%rsp), %r12 leaq 0x8(%rsp), %r13 movq 0x28(%rsi), %rax testq %rax, %rax je 0x3453bd cmpq $0x0, 0x4d0(%rax) je 0x3453bd movq %rax, 0x8(%rsp) movq %r12, %rdi movq %r13, %rsi callq 0x34cbf2 movq 0x10(%rsp), %rsi movq 0x18(%rsi), %rax movq %rax, 0x10(%rsp) addq $0x20, %rsi movq %rbx, %rdi callq 0x34aefc movq 0x10(%rsp), %rsi testq %rsi, %rsi jne 0x345395 movq %r14, 0x58(%rsp) movq 0x18(%rsp), %rdi testq %rdi, %rdi je 0x3453f0 callq 0x280464 movq 0x90(%rsp), %rax leaq 0x20(%rsp), %r14 cmpq 0x70(%rsp), %rax jne 0x345440 leaq 0x10(%rsp), %rdi movq %r14, (%rdi) leaq 0x2641d4(%rip), %rsi # 0x5a95e7 leaq 0x2641f8(%rip), %rdx # 0x5a9612 callq 0x209290 leaq 0x10(%rsp), %rdi callq 0x349a7a movq 0x10(%rsp), %rdi cmpq %r14, %rdi je 0x345440 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movl $0x478, %edi # imm = 0x478 callq 0x1a5230 movq %rax, %r12 leaq 0x10(%rsp), %rdi movq %r14, (%rdi) leaq 0x2641b7(%rip), %rsi # 0x5a9613 leaq 0x2641bd(%rip), %rdx # 0x5a9620 callq 0x209290 leaq 0x10(%rsp), %rsi movq %r12, %rdi callq 0x2403ce movq %r12, 0x8(%r15) movq 0x10(%rsp), %rdi cmpq %r14, %rdi je 0x345490 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0xa8(%rsp), %rax movq %rax, %rcx subq 0x88(%rsp), %rcx shrq $0x3, %rcx cmpq $0x1, %rax adcq $-0x1, %rcx shlq $0x6, %rcx movq 0x80(%rsp), %r14 movq 0x90(%rsp), %rax subq 0x98(%rsp), %rax sarq $0x3, %rax subq 0x70(%rsp), %r14 sarq $0x3, %r14 addq %rax, %r14 addq %rcx, %r14 movl %r14d, 0x450(%r12) movl %r14d, %ebx shlq $0x3, %rbx movq %rbx, %rdi callq 0x1a57a0 movq %rax, %r13 movq %rax, %rdi xorl %esi, %esi movq %rbx, %rdx callq 0x1a54e0 movq %r13, 0x458(%r12) testl %r14d, %r14d je 0x3455f0 leaq 0x14(%rsp), %rbx xorl %r14d, %r14d movl $0x3f800000, %r15d # imm = 0x3F800000 leaq 0x10(%rsp), %rbp xorl %r13d, %r13d movq 0x70(%rsp), %rdx movq 0x88(%rsp), %rcx movq %rdx, %rax subq 0x78(%rsp), %rax sarq $0x3, %rax addq %r13, %rax js 0x345558 cmpq $0x3f, %rax ja 0x345561 addq %r14, %rdx movq %rdx, %rax jmp 0x34557a movq %rax, %rdx sarq $0x6, %rdx jmp 0x345568 movq %rax, %rdx shrq $0x6, %rdx movq %rdx, %rsi shlq $0x6, %rsi subq %rsi, %rax shlq $0x3, %rax addq (%rcx,%rdx,8), %rax movq (%rax), %rdx movl %r15d, 0x10(%rsp) xorps %xmm0, %xmm0 movups %xmm0, (%rbx) movl %r15d, 0x24(%rsp) movups %xmm0, 0x14(%rbx) movl %r15d, 0x38(%rsp) movups %xmm0, 0x28(%rbx) movl %r15d, 0x4c(%rsp) movq 0x50(%rsp), %rdi movq 0x58(%rsp), %rsi leaq 0xb8(%rsp), %rcx movq %rbp, %r8 callq 0x34587c movq 0x458(%r12), %rcx movq %rax, (%rcx,%r14) movq 0x458(%r12), %rax movq (%rax,%r14), %rax movq %r12, 0x448(%rax) incq %r13 movl 0x450(%r12), %eax addq $0x8, %r14 cmpq %rax, %r13 jb 0x34552c leaq 0xb8(%rsp), %rsi movq 0x50(%rsp), %rdi callq 0x346134 movq (%rsp), %rbp movabsq $0x7fffffff8, %r14 # imm = 0x7FFFFFFF8 movq 0xe8(%rsp), %rbx movq 0xf0(%rsp), %r15 subq %rbx, %r15 je 0x345654 movq %r15, %rax shrq $0x3, %rax movl %eax, 0x10(%rbp) movq %r15, %rdi andq %r14, %rdi callq 0x1a57a0 movq %rax, 0x18(%rbp) movq %rax, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x1a5240 movq %rbx, 0xf0(%rsp) movq 0x118(%rsp), %rbx movq 0x120(%rsp), %r15 subq %rbx, %r15 je 0x345698 movq %r15, %rax shrq $0x3, %rax movl %eax, 0x50(%rbp) movq %r15, %rdi andq %r14, %rdi callq 0x1a57a0 movq %rax, 0x58(%rbp) movq %rax, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x1a5240 movq %rbx, 0x120(%rsp) movq 0x100(%rsp), %rbx movq 0x108(%rsp), %r15 subq %rbx, %r15 je 0x3456dc movq %r15, %rax shrq $0x3, %rax movl %eax, 0x60(%rbp) movq %r15, %rdi andq %r14, %rdi callq 0x1a57a0 movq %rax, 0x68(%rbp) movq %rax, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x1a5240 movq %rbx, 0x108(%rsp) movq 0x130(%rsp), %rbx movq 0x138(%rsp), %r15 subq %rbx, %r15 je 0x345720 movq %r15, %rax shrq $0x3, %rax movl %eax, 0x20(%rbp) movq %r15, %rdi andq %r14, %rdi callq 0x1a57a0 movq %rax, 0x28(%rbp) movq %rax, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x1a5240 movq %rbx, 0x138(%rsp) movq 0x148(%rsp), %rbx movq 0x150(%rsp), %r15 subq %rbx, %r15 je 0x345764 movq %r15, %rax shrq $0x3, %rax movl %eax, 0x40(%rbp) andq %r15, %r14 movq %r14, %rdi callq 0x1a57a0 movq %rax, 0x48(%rbp) movq %rax, %rdi movq %rbx, %rsi movq %r15, %rdx callq 0x1a5240 movq %rbx, 0x150(%rsp) leaq 0xe8(%rsp), %rbx leaq 0x118(%rsp), %r15 leaq 0x100(%rsp), %r14 leaq 0x130(%rsp), %r12 leaq 0x148(%rsp), %r13 cmpl $0x0, 0x10(%rbp) jne 0x345796 orb $0x1, (%rbp) leaq 0x60(%rsp), %rdi callq 0x34c938 leaq 0x160(%rsp), %rdi callq 0x34af46 movq %r13, %rdi callq 0x34a9dc movq %r12, %rdi callq 0x34aa4e movq %r15, %rdi callq 0x34aaba movq %r14, %rdi callq 0x34ab06 movq %rbx, %rdi callq 0x34ab52 leaq 0xb8(%rsp), %rdi callq 0x34ad36 addq $0x208, %rsp # imm = 0x208 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq %rax, %rbx movq 0x10(%rsp), %rdi cmpq %r14, %rdi je 0x34585d movq 0x20(%rsp), %rsi incq %rsi jmp 0x345834 jmp 0x34585a movq %rax, %rbx movq 0x10(%rsp), %rdi cmpq %r14, %rdi je 0x34582c movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x34582c movq %rax, %rbx movl $0x478, %esi # imm = 0x478 movq %r12, %rdi callq 0x1a5190 jmp 0x34585d movq %rax, %rbx jmp 0x345867 jmp 0x345846 jmp 0x34585a jmp 0x345846 movq %rax, %rbx movq 0x18(%rsp), %rdi testq %rdi, %rdi je 0x34585d callq 0x280464 jmp 0x34585d movq %rax, %rbx leaq 0x60(%rsp), %rdi callq 0x34c938 leaq 0xb8(%rsp), %rdi callq 0x34a068 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderLoader.cpp
Assimp::BlenderImporter::CheckActualType(Assimp::Blender::ElemBase const*, char const*)
void BlenderImporter::CheckActualType(const ElemBase* dt, const char* check) { ai_assert(dt); if (strcmp(dt->dna_type,check)) { ThrowException((format(), "Expected object at ",std::hex,dt," to be of type `",check, "`, but it claims to be a `",dt->dna_type,"`instead" )); } }
pushq %r14 pushq %rbx subq $0x1a8, %rsp # imm = 0x1A8 movq %rsi, 0x8(%rsp) testq %rdi, %rdi je 0x3477d6 movq %rdi, %rbx movq 0x8(%rdi), %rdi callq 0x1a5f30 testl %eax, %eax je 0x3477cb leaq 0x30(%rsp), %r14 movq %r14, %rdi callq 0x1a6170 leaq 0x262546(%rip), %rsi # 0x5a9c2c movl $0x13, %edx movq %r14, %rdi callq 0x1a61e0 leaq 0x30(%rsp), %rdi movq (%rdi), %rax movq -0x18(%rax), %rax movl 0x48(%rsp,%rax), %ecx andl $-0x4b, %ecx orl $0x8, %ecx movl %ecx, 0x48(%rsp,%rax) movq %rbx, %rsi callq 0x1a57b0 leaq 0x263774(%rip), %rsi # 0x5aae90 leaq 0x30(%rsp), %rdi movl $0x10, %edx callq 0x1a61e0 leaq 0x30(%rsp), %rdi leaq 0x8(%rsp), %rsi callq 0x2477a8 movq %rax, %r14 leaq 0x2624fc(%rip), %rsi # 0x5a9c40 movl $0x1a, %edx movq %rax, %rdi callq 0x1a61e0 addq $0x8, %rbx movq %r14, %rdi movq %rbx, %rsi callq 0x25eb56 movq %rax, %rbx leaq 0x2624f1(%rip), %rsi # 0x5a9c5b movl $0x8, %edx movq %rax, %rdi callq 0x1a61e0 addq $0x8, %rbx leaq 0x10(%rsp), %rdi movq %rbx, %rsi callq 0x1a5690 leaq 0x10(%rsp), %rdi callq 0x349a7a leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x3477ad movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x4647dc(%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 leaq 0x2623f7(%rip), %rdi # 0x5a9bd4 leaq 0x261ef6(%rip), %rsi # 0x5a96da leaq 0x2623ec(%rip), %rcx # 0x5a9bd7 movl $0x30a, %edx # imm = 0x30A callq 0x1a5270 movq %rax, %rbx leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x347818 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x347818 movq %rax, %rbx movq 0x464771(%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/Blender/BlenderLoader.cpp
Assimp::LogFunctions<Assimp::BlenderImporter>::LogDebug(Assimp::Formatter::basic_formatter<char, std::char_traits<char>, std::allocator<char>> const&)
static void LogDebug(const Formatter::format& message) { if (!DefaultLogger::isNullLogger()) { ASSIMP_LOG_DEBUG(Prefix()+(std::string)message); } }
pushq %r15 pushq %r14 pushq %rbx subq $0x40, %rsp movq %rdi, %r14 callq 0x2410fc testb %al, %al jne 0x34b641 callq 0x241234 movq %rax, %rbx addq $0x8, %r14 leaq 0x20(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x1a5690 leaq 0x25de02(%rip), %rcx # 0x5a93b0 movl $0x7, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x1a5260 leaq 0x10(%rsp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi je 0x34b5e6 movq %rsi, (%rsp) movq (%rcx), %rdx movq %rdx, 0x10(%rsp) jmp 0x34b5f0 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq %r14, %rsi movq 0x8(%rax), %rdx movq %rdx, 0x8(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq %rbx, %rdi callq 0x241112 movq (%rsp), %rdi cmpq %r14, %rdi je 0x34b626 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x34b641 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x40, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movq (%rsp), %rdi cmpq %r14, %rdi je 0x34b669 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x34b669 movq %rax, %rbx leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x34b684 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/include/assimp/LogAux.h
Assimp::LogFunctions<Assimp::BlenderImporter>::LogError(Assimp::Formatter::basic_formatter<char, std::char_traits<char>, std::allocator<char>> const&)
static void LogError(const Formatter::format& message) { if (!DefaultLogger::isNullLogger()) { ASSIMP_LOG_ERROR(Prefix()+(std::string)message); } }
pushq %r15 pushq %r14 pushq %rbx subq $0x40, %rsp movq %rdi, %r14 callq 0x2410fc testb %al, %al jne 0x34cf5d callq 0x241234 movq %rax, %rbx addq $0x8, %r14 leaq 0x20(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x1a5690 leaq 0x25c4e6(%rip), %rcx # 0x5a93b0 movl $0x7, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x1a5260 leaq 0x10(%rsp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi je 0x34cf02 movq %rsi, (%rsp) movq (%rcx), %rdx movq %rdx, 0x10(%rsp) jmp 0x34cf0c movups (%rcx), %xmm0 movups %xmm0, (%r14) movq %r14, %rsi movq 0x8(%rax), %rdx movq %rdx, 0x8(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq %rbx, %rdi callq 0x2411ba movq (%rsp), %rdi cmpq %r14, %rdi je 0x34cf42 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x34cf5d movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x40, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movq (%rsp), %rdi cmpq %r14, %rdi je 0x34cf85 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x34cf85 movq %rax, %rbx leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x34cfa0 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/include/assimp/LogAux.h
Assimp::Blender::SectionParser::Next()
void SectionParser :: Next() { stream.SetCurrentPos(current.start + current.size); const char tmp[] = { (const char)stream.GetI1(), (const char)stream.GetI1(), (const char)stream.GetI1(), (const char)stream.GetI1() }; current.id = std::string(tmp,tmp[3]?4:tmp[2]?3:tmp[1]?2:1); current.size = stream.GetI4(); current.address.val = ptr64 ? stream.GetU8() : stream.GetU4(); current.dna_index = stream.GetI4(); current.num = stream.GetI4(); current.start = stream.GetCurrentPos(); if (stream.GetRemainingSizeToLimit() < current.size) { throw DeadlyImportError("BLEND: invalid size of file block"); } #ifdef ASSIMP_BUILD_BLENDER_DEBUG ASSIMP_LOG_DEBUG(current.id); #endif }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x30, %rsp movq %rdi, %rbx movq 0x48(%rdi), %rdi movl (%rbx), %eax movq 0x10(%rdi), %rsi addq 0x28(%rbx), %rsi addq %rax, %rsi callq 0x34b4b8 movq 0x48(%rbx), %rdi callq 0x34fd84 movb %al, 0xc(%rsp) movq 0x48(%rbx), %rdi callq 0x34fd84 movl %eax, %ebp movb %al, 0xd(%rsp) movq 0x48(%rbx), %rdi callq 0x34fd84 movl %eax, %r14d movb %al, 0xe(%rsp) movq 0x48(%rbx), %rdi callq 0x34fd84 movb %al, 0xf(%rsp) movl $0x4, %ecx testb %al, %al jne 0x34f87a movl $0x3, %ecx testb %r14b, %r14b jne 0x34f87a cmpb $0x1, %bpl movl $0x2, %ecx sbbq $0x0, %rcx leaq 0x20(%rsp), %r12 movq %r12, -0x10(%r12) leaq (%rsp,%rcx), %rdx addq $0xc, %rdx leaq 0x10(%rsp), %r15 leaq 0xc(%rsp), %rsi movq %r15, %rdi callq 0x209290 leaq 0x8(%rbx), %r14 movq %r14, %rdi movq %r15, %rsi callq 0x1a58d0 movq (%r15), %rdi cmpq %r12, %rdi je 0x34f8c2 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x48(%rbx), %rdi callq 0x350190 cltq movq %rax, 0x28(%rbx) movq 0x48(%rbx), %rdi cmpb $0x1, 0x50(%rbx) jne 0x34f8e2 callq 0x34ff1a jmp 0x34f8e9 callq 0x350088 movl %eax, %eax movq %rax, 0x30(%rbx) movq 0x48(%rbx), %rdi callq 0x350190 movl %eax, 0x38(%rbx) movq 0x48(%rbx), %rdi callq 0x350190 cltq movq %rax, 0x40(%rbx) movq 0x28(%rbx), %rax movq 0x48(%rbx), %rcx movl 0x18(%rcx), %edx subl 0x10(%rcx), %edx movl %edx, (%rbx) movl 0x28(%rcx), %edx subl 0x18(%rcx), %edx cmpq %rdx, %rax ja 0x34f940 callq 0x241234 movq (%r14), %rsi movq %rax, %rdi callq 0x241112 addq $0x30, %rsp popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x10(%rsp), %rdi movq %r12, (%rdi) leaq 0x25ab0c(%rip), %rsi # 0x5aa468 leaq 0x25ab26(%rip), %rdx # 0x5aa489 callq 0x209290 movb $0x1, %bpl leaq 0x10(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x38ddb9(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x38dd85(%rip), %rsi # 0x6dd710 movq 0x45c5ce(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x10(%rsp), %rdi cmpq %r12, %rdi je 0x34f9b4 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x34f9be jmp 0x34f9c6 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderDNA.cpp
void Assimp::Blender::Structure::Convert<Assimp::Blender::Object>(Assimp::Blender::Object&, Assimp::Blender::FileDatabase const&) const
void Structure :: Convert<Object> ( Object& dest, const FileDatabase& db ) const { ReadField<ErrorPolicy_Fail>(dest.id,"id",db); int temp = 0; ReadField<ErrorPolicy_Fail>(temp,"type",db); dest.type = static_cast<Assimp::Blender::Object::Type>(temp); ReadFieldArray2<ErrorPolicy_Warn>(dest.obmat,"obmat",db); ReadFieldArray2<ErrorPolicy_Warn>(dest.parentinv,"parentinv",db); ReadFieldArray<ErrorPolicy_Warn>(dest.parsubstr,"parsubstr",db); { std::shared_ptr<Object> parent; ReadFieldPtr<ErrorPolicy_Warn>(parent,"*parent",db); dest.parent = parent.get(); } ReadFieldPtr<ErrorPolicy_Warn>(dest.track,"*track",db); ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy,"*proxy",db); ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_from,"*proxy_from",db); ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_group,"*proxy_group",db); ReadFieldPtr<ErrorPolicy_Warn>(dest.dup_group,"*dup_group",db); ReadFieldPtr<ErrorPolicy_Fail>(dest.data,"*data",db); ReadField<ErrorPolicy_Igno>(dest.modifiers,"modifiers",db); db.reader->IncPtr(size); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 addq $0x10, %rsi leaq 0x210cbe(%rip), %rdx # 0x561635 movq %rbx, %rcx callq 0x353e3c leaq 0x14(%rsp), %r12 movl $0x0, (%r12) leaq 0x21b3ba(%rip), %rdx # 0x56bd4d movq %r14, %rdi movq %r12, %rsi movq %rbx, %rcx callq 0x353f72 movl (%r12), %eax movl %eax, 0x428(%r15) leaq 0x42c(%r15), %rsi leaq 0x259b9e(%rip), %rdx # 0x5aa558 movq %r14, %rdi movq %rbx, %rcx callq 0x3540a8 leaq 0x46c(%r15), %rsi leaq 0x259b8b(%rip), %rdx # 0x5aa55e movq %r14, %rdi movq %rbx, %rcx callq 0x3540a8 leaq 0x4ac(%r15), %rsi leaq 0x259b7c(%rip), %rdx # 0x5aa568 movq %r14, %rdi movq %rbx, %rcx callq 0x3544ec xorps %xmm0, %xmm0 movq %rsp, %rsi movaps %xmm0, (%rsi) leaq 0x259b6b(%rip), %rdx # 0x5aa572 movq %r14, %rdi movq %rbx, %rcx xorl %r8d, %r8d callq 0x354898 movq (%rsp), %rax movq %rax, 0x4d0(%r15) movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x350a2f callq 0x280464 leaq 0x4d8(%r15), %rsi leaq 0x259b3d(%rip), %rdx # 0x5aa57a movq %r14, %rdi movq %rbx, %rcx xorl %r8d, %r8d callq 0x354898 leaq 0x4e8(%r15), %rsi leaq 0x259b28(%rip), %rdx # 0x5aa581 movq %r14, %rdi movq %rbx, %rcx xorl %r8d, %r8d callq 0x354898 leaq 0x4f8(%r15), %rsi leaq 0x259b13(%rip), %rdx # 0x5aa588 movq %r14, %rdi movq %rbx, %rcx xorl %r8d, %r8d callq 0x354898 leaq 0x508(%r15), %rsi leaq 0x259b03(%rip), %rdx # 0x5aa594 movq %r14, %rdi movq %rbx, %rcx xorl %r8d, %r8d callq 0x354898 leaq 0x518(%r15), %rsi leaq 0x259af4(%rip), %rdx # 0x5aa5a1 movq %r14, %rdi movq %rbx, %rcx xorl %r8d, %r8d callq 0x354b3c leaq 0x528(%r15), %rsi leaq 0x259ae3(%rip), %rdx # 0x5aa5ac movq %r14, %rdi movq %rbx, %rcx xorl %r8d, %r8d callq 0x354de0 addq $0x538, %r15 # imm = 0x538 leaq 0x259acd(%rip), %rdx # 0x5aa5b2 movq %r14, %rdi movq %r15, %rsi movq %rbx, %rcx callq 0x355084 movq 0x80(%rbx), %rdi movq 0x68(%r14), %rsi callq 0x3551ba addq $0x18, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %rbx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x350b21 callq 0x280464 movq %rbx, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderScene.cpp
void Assimp::Blender::Structure::_defaultInitializer<2>::operator()<Assimp::Blender::ID>(Assimp::Blender::ID&, char const*)
void operator ()(T& /*out*/,const char* = "") { // obviously, it is crucial that _DefaultInitializer is used // only from within a catch clause. throw DeadlyImportError("Constructing BlenderDNA Structure encountered an error"); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x24cc62(%rip), %rsi # 0x5aadb5 leaq 0x24cc91(%rip), %rdx # 0x5aadeb leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x37f5bd(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x37f589(%rip), %rsi # 0x6dd710 movq 0x44ddd2(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x35e1b0 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x35e1ba jmp 0x35e1c2 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderDNA.h
unsigned short Assimp::StreamReader<true, true>::Get<unsigned short>()
T Get() { if ( current + sizeof(T) > limit) { throw DeadlyImportError("End of file or stream limit was reached"); } T f; ::memcpy (&f, current, sizeof(T)); Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le); current += sizeof(T); return f; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq 0x18(%rdi), %rcx leaq 0x2(%rcx), %rax cmpq 0x28(%rdi), %rax ja 0x35e420 movzwl (%rcx), %ecx movl %ecx, %edx shrl $0x8, %edx cmpb $0x0, 0x30(%rdi) movl %edx, %esi cmovnel %ecx, %esi cmovel %ecx, %edx movq %rax, 0x18(%rdi) shll $0x8, %edx movzbl %sil, %eax orl %edx, %eax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x239d95(%rip), %rsi # 0x5981d2 leaq 0x239db5(%rip), %rdx # 0x5981f9 leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x37f2d3(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x37f29f(%rip), %rsi # 0x6dd710 movq 0x44dae8(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x35e49a movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x35e4a4 jmp 0x35e4ac movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/include/assimp/StreamReader.h
float Assimp::StreamReader<true, true>::Get<float>()
T Get() { if ( current + sizeof(T) > limit) { throw DeadlyImportError("End of file or stream limit was reached"); } T f; ::memcpy (&f, current, sizeof(T)); Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le); current += sizeof(T); return f; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq 0x18(%rdi), %rcx leaq 0x4(%rcx), %rax cmpq 0x28(%rdi), %rax ja 0x35e5aa movl (%rcx), %ecx movl %ecx, %edx bswapl %edx cmpb $0x0, 0x30(%rdi) cmovnel %ecx, %edx movd %edx, %xmm0 movq %rax, 0x18(%rdi) addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x239c0b(%rip), %rsi # 0x5981d2 leaq 0x239c2b(%rip), %rdx # 0x5981f9 leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x37f149(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x37f115(%rip), %rsi # 0x6dd710 movq 0x44d95e(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x35e624 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x35e62e jmp 0x35e636 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/include/assimp/StreamReader.h
void Assimp::Blender::Structure::_defaultInitializer<2>::operator()<std::shared_ptr<Assimp::Blender::ElemBase>>(std::shared_ptr<Assimp::Blender::ElemBase>&, char const*)
void operator ()(T& /*out*/,const char* = "") { // obviously, it is crucial that _DefaultInitializer is used // only from within a catch clause. throw DeadlyImportError("Constructing BlenderDNA Structure encountered an error"); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x24ae76(%rip), %rsi # 0x5aadb5 leaq 0x24aea5(%rip), %rdx # 0x5aadeb leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x37d7d1(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x37d79d(%rip), %rsi # 0x6dd710 movq 0x44bfe6(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x35ff9c movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x35ffa6 jmp 0x35ffae movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderDNA.h
void Assimp::Blender::Structure::_defaultInitializer<1>::operator()<std::shared_ptr<Assimp::Blender::GroupObject>>(std::shared_ptr<Assimp::Blender::GroupObject>&, char const*)
void operator ()(T& out, const char* reason = "<add reason>") { ASSIMP_LOG_WARN(reason); // ... and let the show go on _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); }
pushq %r14 pushq %rbx pushq %rax movq %rdx, %rbx movq %rsi, %r14 callq 0x241234 movq %rax, %rdi movq %rbx, %rsi callq 0x241182 xorps %xmm0, %xmm0 movq 0x8(%r14), %rdi movups %xmm0, (%r14) addq $0x8, %rsp testq %rdi, %rdi je 0x3604dc popq %rbx popq %r14 jmp 0x280464 popq %rbx popq %r14 retq
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderDNA.h
void Assimp::Blender::Structure::_defaultInitializer<2>::operator()<Assimp::Blender::ModifierData>(Assimp::Blender::ModifierData&, char const*)
void operator ()(T& /*out*/,const char* = "") { // obviously, it is crucial that _DefaultInitializer is used // only from within a catch clause. throw DeadlyImportError("Constructing BlenderDNA Structure encountered an error"); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x249a06(%rip), %rsi # 0x5aadb5 leaq 0x249a35(%rip), %rdx # 0x5aadeb leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x37c361(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x37c32d(%rip), %rsi # 0x6dd710 movq 0x44ab76(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x36140c movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x361416 jmp 0x36141e movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderDNA.h
void Assimp::Blender::Structure::_defaultInitializer<2>::operator()<float [3]>(float (&) [3], char const*)
void operator ()(T& /*out*/,const char* = "") { // obviously, it is crucial that _DefaultInitializer is used // only from within a catch clause. throw DeadlyImportError("Constructing BlenderDNA Structure encountered an error"); }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x242fbe(%rip), %rsi # 0x5aadb5 leaq 0x242fed(%rip), %rdx # 0x5aadeb leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi callq 0x1a53e0 leaq 0x375919(%rip), %rax # 0x6dd738 movq %rax, (%rbx) xorl %ebp, %ebp leaq 0x3758e5(%rip), %rsi # 0x6dd710 movq 0x44412e(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x367e54 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x367e5e jmp 0x367e66 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderDNA.h
Assimp::Blender::PackedFile* Assimp::Blender::Structure::_allocate<Assimp::Blender::PackedFile>(std::shared_ptr<Assimp::Blender::PackedFile>&, unsigned long&) const
T* _allocate(std::shared_ptr<T>& out, size_t& s) const { out = std::shared_ptr<T>(new T()); s = 1; return out.get(); }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdx, %r14 movq %rsi, %rbx movl $0x28, %edi callq 0x1a5230 xorps %xmm0, %xmm0 movaps %xmm0, (%rax) movaps %xmm0, 0x10(%rax) leaq 0x37806c(%rip), %rcx # 0x6e10e8 movq %rcx, (%rax) movups %xmm0, 0x18(%rax) leaq 0x8(%rsp), %r15 movq %rax, -0x8(%r15) movq %r15, %rdi movq %rax, %rsi callq 0x3691e0 movaps -0x8(%r15), %xmm0 xorps %xmm1, %xmm1 movaps %xmm1, -0x8(%r15) movq 0x8(%rbx), %rdi movups %xmm0, (%rbx) testq %rdi, %rdi je 0x3690c4 callq 0x280464 movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x3690c4 callq 0x280464 movq $0x1, (%r14) movq (%rbx), %rax addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderDNA.h
Assimp::Blender::getCustomDataLayerData(Assimp::Blender::CustomData const&, Assimp::Blender::CustomDataType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const ElemBase * getCustomDataLayerData(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) { const std::shared_ptr<CustomDataLayer> pLayer = getCustomDataLayer(customdata, cdtype, name); if (pLayer && pLayer->data) { return pLayer->data.get(); } return nullptr; }
pushq %rbx subq $0x10, %rsp movq %rdx, %rcx movl %esi, %edx movq %rdi, %rsi movq %rsp, %rbx movq %rbx, %rdi callq 0x36c889 movq (%rbx), %rax testq %rax, %rax je 0x36c933 movq 0x70(%rax), %rbx jmp 0x36c935 xorl %ebx, %ebx movq 0x8(%rsp), %rdi testq %rdi, %rdi je 0x36c944 callq 0x280464 movq %rbx, %rax addq $0x10, %rsp popq %rbx retq
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderCustomData.cpp
bool Assimp::Blender::read<Assimp::Blender::MTexPoly>(Assimp::Blender::Structure const&, Assimp::Blender::MTexPoly*, unsigned long, Assimp::Blender::FileDatabase const&)
bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { for (size_t i = 0; i < cnt; ++i) { T read; s.Convert(read, db); *p = read; p++; } return true; }
testq %rdx, %rdx je 0x36cbf8 pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x28, %rsp movq %rcx, %rbx movq %rdx, %r14 movq %rsi, %r15 movq %rdi, %r12 addq $0x10, %r15 leaq 0x374315(%rip), %rbp # 0x6e0ec0 leaq 0x8(%rsp), %r13 movq $0x0, 0x10(%rsp) movq %rbp, 0x8(%rsp) movq %r12, %rdi movq %r13, %rsi movq %rbx, %rdx callq 0x351fea movq 0x10(%rsp), %rax movq %rax, -0x8(%r15) leaq 0x18(%rsp), %rax movups (%rax), %xmm0 movups %xmm0, (%r15) addq $0x20, %r15 decq %r14 jne 0x36cbb0 addq $0x28, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp movb $0x1, %al retq
/hbina[P]fatuous/thirdparty/assimp/code/Blender/BlenderCustomData.cpp
(anonymous namespace)::ResolveObjectPlacement(aiMatrix4x4t<float>&, Assimp::IFC::Schema_2x3::IfcObjectPlacement const&, Assimp::IFC::ConversionData&)
void ResolveObjectPlacement(aiMatrix4x4& m, const Schema_2x3::IfcObjectPlacement& place, ConversionData& conv) { if (const Schema_2x3::IfcLocalPlacement* const local = place.ToPtr<Schema_2x3::IfcLocalPlacement>()){ IfcMatrix4 tmp; ConvertAxisPlacement(tmp, *local->RelativePlacement, conv); m = static_cast<aiMatrix4x4>(tmp); if (local->PlacementRelTo) { aiMatrix4x4 tmp; ResolveObjectPlacement(tmp,local->PlacementRelTo.Get(),conv); m = tmp * m; } } else { IFCImporter::LogWarn("skipping unknown IfcObjectPlacement entity, type is " + place.GetClassName()); } }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x1f8, %rsp # imm = 0x1F8 movq %rdx, %r14 movq %rsi, %r12 movq %rdi, %rbx movq (%rsi), %rax addq -0x18(%rax), %r12 leaq 0x3703a2(%rip), %rsi # 0x6e1cc8 leaq 0x370e13(%rip), %rdx # 0x6e2740 movq %r12, %rdi movq $-0x1, %rcx callq 0x1a6190 testq %rax, %rax je 0x371bba movq %rax, %r15 movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000 leaq 0x80(%rsp), %r12 movq %rax, (%r12) xorps %xmm0, %xmm0 movups %xmm0, 0x8(%r12) movups %xmm0, 0x18(%r12) movq %rax, 0x28(%r12) movups %xmm0, 0x30(%r12) movups %xmm0, 0x40(%r12) movq %rax, 0x50(%r12) movups %xmm0, 0x58(%r12) movups %xmm0, 0x68(%r12) movq %rax, 0x78(%r12) movq 0x30(%r15), %rsi movq %r12, %rdi movq %r14, %rdx callq 0x42a430 movupd (%r12), %xmm0 movupd 0x10(%r12), %xmm1 cvtpd2ps %xmm1, %xmm1 cvtpd2ps %xmm0, %xmm0 unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0] movupd %xmm0, (%rbx) movupd 0x20(%r12), %xmm0 movupd 0x30(%r12), %xmm1 cvtpd2ps %xmm1, %xmm1 cvtpd2ps %xmm0, %xmm0 unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0] movupd %xmm0, 0x10(%rbx) movupd 0x40(%r12), %xmm0 movupd 0x50(%r12), %xmm1 cvtpd2ps %xmm1, %xmm1 cvtpd2ps %xmm0, %xmm0 unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0] movupd %xmm0, 0x20(%rbx) movupd 0x60(%r12), %xmm0 movupd 0x70(%r12), %xmm1 cvtpd2ps %xmm1, %xmm1 cvtpd2ps %xmm0, %xmm0 unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0] movupd %xmm0, 0x30(%rbx) cmpb $0x1, 0x28(%r15) jne 0x371ca3 movl $0x3f800000, %eax # imm = 0x3F800000 leaq 0x30(%rsp), %r12 movl %eax, (%r12) xorpd %xmm0, %xmm0 movupd %xmm0, 0x4(%r12) movl %eax, 0x14(%r12) movupd %xmm0, 0x18(%r12) movl %eax, 0x28(%r12) movupd %xmm0, 0x2c(%r12) movl %eax, 0x3c(%r12) movq 0x20(%r15), %rdi callq 0x37405c movq %r12, %rdi movq %rax, %rsi movq %r14, %rdx callq 0x371901 movaps (%r12), %xmm9 movups 0x4(%r12), %xmm3 movups 0x8(%r12), %xmm8 movups 0xc(%r12), %xmm0 movaps 0x10(%r12), %xmm14 movups 0x14(%r12), %xmm15 movups 0x18(%r12), %xmm11 movups 0x1c(%r12), %xmm12 movaps 0x20(%r12), %xmm7 movups 0x24(%r12), %xmm10 movups 0x28(%r12), %xmm4 movups 0x2c(%r12), %xmm5 movaps 0x30(%r12), %xmm1 shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0] movups (%rbx), %xmm13 movaps %xmm13, 0x70(%rsp) movups 0x10(%rbx), %xmm6 movups 0x20(%rbx), %xmm2 mulps %xmm6, %xmm3 shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0] mulps %xmm13, %xmm9 addps %xmm3, %xmm9 movups 0x30(%rbx), %xmm3 shufps $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0] mulps %xmm2, %xmm8 addps %xmm9, %xmm8 shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0] mulps %xmm3, %xmm0 addps %xmm8, %xmm0 movss 0x34(%r12), %xmm13 movss 0x38(%r12), %xmm8 movss 0x3c(%r12), %xmm9 movups %xmm0, (%rbx) shufps $0x0, %xmm15, %xmm15 # xmm15 = xmm15[0,0,0,0] mulps %xmm6, %xmm15 shufps $0x0, %xmm14, %xmm14 # xmm14 = xmm14[0,0,0,0] movaps 0x70(%rsp), %xmm0 mulps %xmm0, %xmm14 addps %xmm15, %xmm14 shufps $0x0, %xmm11, %xmm11 # xmm11 = xmm11[0,0,0,0] mulps %xmm2, %xmm11 addps %xmm14, %xmm11 shufps $0x0, %xmm12, %xmm12 # xmm12 = xmm12[0,0,0,0] mulps %xmm3, %xmm12 addps %xmm11, %xmm12 movups %xmm12, 0x10(%rbx) shufps $0x0, %xmm10, %xmm10 # xmm10 = xmm10[0,0,0,0] mulps %xmm6, %xmm10 shufps $0x0, %xmm7, %xmm7 # xmm7 = xmm7[0,0,0,0] mulps %xmm0, %xmm7 addps %xmm10, %xmm7 shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0] mulps %xmm2, %xmm4 addps %xmm7, %xmm4 shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0] mulps %xmm3, %xmm5 addps %xmm4, %xmm5 movups %xmm5, 0x20(%rbx) shufps $0x0, %xmm13, %xmm13 # xmm13 = xmm13[0,0,0,0] mulps %xmm6, %xmm13 shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0] mulps %xmm0, %xmm1 addps %xmm13, %xmm1 shufps $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0] mulps %xmm2, %xmm8 addps %xmm1, %xmm8 shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0] mulps %xmm3, %xmm9 addps %xmm8, %xmm9 movups %xmm9, 0x30(%rbx) jmp 0x371ca3 movq 0x10(%r12), %rsi leaq 0x10(%rsp), %rbx leaq 0xf(%rsp), %rdx movq %rbx, %rdi callq 0x23ca1c leaq 0x23b05d(%rip), %rcx # 0x5acc35 movl $0x34, %r8d movq %rbx, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x1a5260 leaq 0x40(%rsp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rdx movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rdx je 0x371c11 movq %rdx, 0x30(%rsp) movq (%rcx), %rdx movq %rdx, 0x40(%rsp) jmp 0x371c1a movupd (%rcx), %xmm0 movupd %xmm0, (%r14) movq 0x8(%rax), %rdx leaq 0x30(%rsp), %rsi movq %rdx, 0x8(%rsi) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) leaq 0x80(%rsp), %rdi callq 0x27f810 leaq 0x80(%rsp), %rdi callq 0x373640 movq 0x43a339(%rip), %rsi # 0x7abf90 leaq 0x80(%rsp), %rdi callq 0x1a5d00 leaq 0xf0(%rsp), %rdi callq 0x1a5ca0 movq 0x30(%rsp), %rdi cmpq %r14, %rdi je 0x371c88 movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x371ca3 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x1f8, %rsp # imm = 0x1F8 popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %rbx movq 0x43a2d4(%rip), %rsi # 0x7abf90 leaq 0x80(%rsp), %rdi callq 0x1a5d00 leaq 0xf0(%rsp), %rdi callq 0x1a5ca0 jmp 0x371cdb movq %rax, %rbx movq 0x30(%rsp), %rdi cmpq %r14, %rdi je 0x371cf7 movq 0x40(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x371cf7 movq %rax, %rbx leaq 0x20(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x371d12 movq 0x20(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCLoader.cpp
(anonymous namespace)::RateRepresentationPredicate::Rate(Assimp::IFC::Schema_2x3::IfcRepresentation const*) const
int Rate(const Schema_2x3::IfcRepresentation* r) const { // the smaller, the better if (! r->RepresentationIdentifier) { // neutral choice if no extra information is specified return 0; } const std::string& name = r->RepresentationIdentifier.Get(); if (name == "MappedRepresentation") { if (!r->Items.empty()) { // take the first item and base our choice on it const Schema_2x3::IfcMappedItem* const m = r->Items.front()->ToPtr<Schema_2x3::IfcMappedItem>(); if (m) { return Rate(m->MappingSource->MappedRepresentation); } } return 100; } return Rate(name); }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx pushq %rax cmpb $0x1, 0x38(%rdi) jne 0x37287b movq %rdi, %r12 leaq 0x23a53c(%rip), %rbx # 0x5acd27 leaq 0x36f4d6(%rip), %r14 # 0x6e1cc8 leaq 0x370347(%rip), %r15 # 0x6e2b40 movl $0x64, %ebp leaq 0x18(%r12), %r13 movq %r13, %rdi movq %rbx, %rsi callq 0x1a60c0 testl %eax, %eax jne 0x37288e movq 0x68(%r12), %rax cmpq 0x70(%r12), %rax je 0x37287d movq (%rax), %rdi callq 0x3746b0 movq (%rax), %rcx addq -0x18(%rcx), %rax movq %rax, %rdi movq %r14, %rsi movq %r15, %rdx movq $-0x1, %rcx callq 0x1a6190 testq %rax, %rax je 0x37287d movq 0x20(%rax), %rdi callq 0x3746e0 movq 0x20(%rax), %rdi callq 0x373322 movq %rax, %rdi movq %r14, %rsi leaq 0x37021a(%rip), %rdx # 0x6e2a80 movq $-0x1, %rcx callq 0x1a6190 movq %rax, %r12 cmpb $0x0, 0x38(%rax) jne 0x3727fe xorl %ebp, %ebp movl %ebp, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq leaq 0x243722(%rip), %rsi # 0x5b5fb7 movq %r13, %rdi callq 0x1a60c0 testl %eax, %eax je 0x37290d leaq 0x23a494(%rip), %rsi # 0x5acd3c movq %r13, %rdi callq 0x1a60c0 testl %eax, %eax je 0x372917 leaq 0x23a48c(%rip), %rsi # 0x5acd47 movq %r13, %rdi callq 0x1a60c0 testl %eax, %eax je 0x372921 leaq 0x243e4d(%rip), %rsi # 0x5b671b movq %r13, %rdi callq 0x1a60c0 testl %eax, %eax je 0x37292b leaq 0x251f1b(%rip), %rsi # 0x5c47fc movq %r13, %rdi callq 0x1a60c0 testl %eax, %eax je 0x372935 leaq 0x25d2b2(%rip), %rsi # 0x5cfba6 movq %r13, %rdi callq 0x1a60c0 xorl %ecx, %ecx testl %eax, %eax movl $0x64, %ebp cmovnel %ecx, %ebp jmp 0x37287d movl $0xfffffffd, %ebp # imm = 0xFFFFFFFD jmp 0x37287d movl $0xfffffff6, %ebp # imm = 0xFFFFFFF6 jmp 0x37287d movl $0xfffffffb, %ebp # imm = 0xFFFFFFFB jmp 0x37287d movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE jmp 0x37287d movl $0x64, %ebp jmp 0x37287d
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCLoader.cpp
Assimp::LogFunctions<Assimp::IFCImporter>::LogError(Assimp::Formatter::basic_formatter<char, std::char_traits<char>, std::allocator<char>> const&)
static void LogError(const Formatter::format& message) { if (!DefaultLogger::isNullLogger()) { ASSIMP_LOG_ERROR(Prefix()+(std::string)message); } }
pushq %r15 pushq %r14 pushq %rbx subq $0x40, %rsp movq %rdi, %r14 callq 0x2410fc testb %al, %al jne 0x373859 callq 0x241234 movq %rax, %rbx addq $0x8, %r14 leaq 0x20(%rsp), %r15 movq %r15, %rdi movq %r14, %rsi callq 0x1a5690 leaq 0x238c0a(%rip), %rcx # 0x5ac3d0 movl $0x5, %r8d movq %r15, %rdi xorl %esi, %esi xorl %edx, %edx callq 0x1a5260 leaq 0x10(%rsp), %r14 movq %r14, -0x10(%r14) movq (%rax), %rsi movq %rax, %rcx addq $0x10, %rcx cmpq %rcx, %rsi je 0x3737fe movq %rsi, (%rsp) movq (%rcx), %rdx movq %rdx, 0x10(%rsp) jmp 0x373808 movups (%rcx), %xmm0 movups %xmm0, (%r14) movq %r14, %rsi movq 0x8(%rax), %rdx movq %rdx, 0x8(%rsp) movq %rcx, (%rax) movq $0x0, 0x8(%rax) movb $0x0, 0x10(%rax) movq %rbx, %rdi callq 0x2411ba movq (%rsp), %rdi cmpq %r14, %rdi je 0x37383e movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x373859 movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 addq $0x40, %rsp popq %rbx popq %r14 popq %r15 retq movq %rax, %rbx movq (%rsp), %rdi cmpq %r14, %rdi je 0x373881 movq 0x10(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x373881 movq %rax, %rbx leaq 0x30(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x37389c movq 0x30(%rsp), %rsi incq %rsi callq 0x1a5190 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/include/assimp/LogAux.h
unsigned long Assimp::STEP::GenericFill<Assimp::IFC::Schema_2x3::IfcRelConnects>(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&, Assimp::IFC::Schema_2x3::IfcRelConnects*)
size_t GenericFill<IfcRelConnects>(const DB& db, const LIST& params, IfcRelConnects* in) { size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in)); if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelConnects"); } return base; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx callq 0x376281 movq 0x10(%rbx), %rax subq 0x8(%rbx), %rax cmpq $0x3f, %rax jbe 0x376379 movl $0x4, %eax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x23d590(%rip), %rsi # 0x5b3926 leaq 0x23d5af(%rip), %rdx # 0x5b394c leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi movq $-0x1, %rdx movq $-0x1, %rcx callq 0x5254bc xorl %ebp, %ebp leaq 0x36b98a(%rip), %rsi # 0x6e1d58 movq 0x435b8b(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x3763f7 movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x376401 jmp 0x376409 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
unsigned long Assimp::STEP::GenericFill<Assimp::IFC::Schema_2x3::IfcSimpleProperty>(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&, Assimp::IFC::Schema_2x3::IfcSimpleProperty*)
size_t GenericFill<IfcSimpleProperty>(const DB& db, const LIST& params, IfcSimpleProperty* in) { size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in)); if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSimpleProperty"); } return base; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x28, %rsp movq %rsi, %rbx callq 0x3780a4 movq 0x10(%rbx), %rax subq 0x8(%rbx), %rax cmpq $0x10, %rax jbe 0x3784e1 movl $0x2, %eax addq $0x28, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %rbx leaq 0x18(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x23ba0a(%rip), %rsi # 0x5b3f08 leaq 0x23ba2c(%rip), %rdx # 0x5b3f31 leaq 0x8(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x8(%rsp), %rsi movq %rbx, %rdi movq $-0x1, %rdx movq $-0x1, %rcx callq 0x5254bc xorl %ebp, %ebp leaq 0x369822(%rip), %rsi # 0x6e1d58 movq 0x433a23(%rip), %rdx # 0x7abf60 movq %rbx, %rdi callq 0x1a5b00 movq %rax, %r14 movq 0x8(%rsp), %rdi cmpq %r15, %rdi je 0x37855f movq 0x18(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x378569 jmp 0x378571 movq %rax, %r14 movq %rbx, %rdi callq 0x1a6080 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
unsigned long Assimp::STEP::GenericFill<Assimp::IFC::Schema_2x3::IfcRelDefines>(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&, Assimp::IFC::Schema_2x3::IfcRelDefines*)
size_t GenericFill<IfcRelDefines>(const DB& db, const LIST& params, IfcRelDefines* in) { size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in)); if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRelDefines"); } do { // convert the 'RelatedObjects' argument std::shared_ptr<const DataType> arg = params[base++]; if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefines,1>::aux_is_derived[0]=true; break; } try { GenericConvert( in->RelatedObjects, arg, db ); break; } catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefines to be a `SET [1:?] OF IfcObject`")); } } while(0); return base; }
pushq %rbp pushq %r15 pushq %r14 pushq %rbx subq $0x58, %rsp movq %rdx, %rbx movq %rsi, %r15 movq %rdi, %r14 callq 0x376281 movq 0x8(%r15), %rax movq 0x10(%r15), %rcx subq %rax, %rcx cmpq $0x40, %rcx jbe 0x37e562 movq 0x40(%rax), %rdi movq %rdi, 0x8(%rsp) movq 0x48(%rax), %rax movq %rax, 0x10(%rsp) testq %rax, %rax je 0x37e504 movq 0x42dab7(%rip), %rcx # 0x7abfa8 cmpb $0x0, (%rcx) je 0x37e4fb incl 0x8(%rax) jmp 0x37e504 lock incl 0x8(%rax) movq 0x8(%rsp), %rdi leaq 0x36380d(%rip), %rsi # 0x6e1d18 leaq 0x3684ce(%rip), %rdx # 0x6e69e0 xorl %ecx, %ecx callq 0x1a6190 testq %rax, %rax je 0x37e527 orb $0x1, 0xa0(%rbx) jmp 0x37e543 addq $0xa8, %rbx leaq 0x7(%rsp), %rdi leaq 0x8(%rsp), %rdx movq %rbx, %rsi movq %r14, %rcx callq 0x41ad5e movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x37e552 callq 0x280464 movl $0x5, %eax addq $0x58, %rsp popq %rbx popq %r14 popq %r15 popq %rbp retq movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 leaq 0x28(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x236bcd(%rip), %rsi # 0x5b514c leaq 0x236beb(%rip), %rdx # 0x5b5171 leaq 0x18(%rsp), %rdi callq 0x209290 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi movq $-0x1, %rdx movq $-0x1, %rcx callq 0x5254bc xorl %ebp, %ebp leaq 0x3637a1(%rip), %rsi # 0x6e1d58 movq 0x42d9a2(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 jmp 0x37e664 movq %rax, %rbx cmpl $0x1, %edx jne 0x37e6cc movq %rbx, %rdi callq 0x1a50d0 movq %rax, %rbx movl $0x10, %edi callq 0x1a5680 movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x10(%rax) movq %rax, %rbx leaq 0x48(%rsp), %r15 movq %r15, -0x10(%r15) leaq 0x236b67(%rip), %rsi # 0x5b5172 leaq 0x236ba8(%rip), %rdx # 0x5b51ba leaq 0x38(%rsp), %rdi callq 0x209290 leaq 0x18(%rsp), %rdi leaq 0x38(%rsp), %rdx movq %rbx, %rsi callq 0x2beb54 movb $0x1, %bpl leaq 0x18(%rsp), %rsi movq %r14, %rdi movq $-0x1, %rdx movq $-0x1, %rcx callq 0x5254bc xorl %ebp, %ebp leaq 0x363703(%rip), %rsi # 0x6e1d58 movq 0x42d904(%rip), %rdx # 0x7abf60 movq %r14, %rdi callq 0x1a5b00 movq %rax, %rbx leaq 0x28(%rsp), %rax movq -0x10(%rax), %rdi cmpq %rax, %rdi je 0x37e682 movq 0x28(%rsp), %rsi incq %rsi callq 0x1a5190 movq 0x38(%rsp), %rdi cmpq %r15, %rdi je 0x37e699 movq 0x48(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x37e6bf jmp 0x37e6c7 movq %rax, %rbx movq 0x38(%rsp), %rdi cmpq %r15, %rdi je 0x37e6bf movq 0x48(%rsp), %rsi incq %rsi callq 0x1a5190 jmp 0x37e6bf movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 callq 0x1a5e20 movq 0x10(%rsp), %rdi testq %rdi, %rdi je 0x37e711 callq 0x280464 jmp 0x37e711 movq %rax, %rdi callq 0x1d8731 movq %rax, %rbx movq 0x18(%rsp), %rdi cmpq %r15, %rdi je 0x37e6ff movq 0x28(%rsp), %rsi incq %rsi callq 0x1a5190 testb %bpl, %bpl jne 0x37e709 jmp 0x37e711 movq %rax, %rbx movq %r14, %rdi callq 0x1a6080 movq %rbx, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen1_2x3.cpp
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcDistributionElementType, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1a8, %edi # imm = 0x1A8 callq 0x1a5230 movq %rax, %rbx leaq 0x363d17(%rip), %rax # 0x6e6a70 movq %rax, 0x190(%rbx) movq $0x0, 0x198(%rbx) leaq 0x23302a(%rip), %rax # 0x5b5d9c movq %rax, 0x1a0(%rbx) leaq 0x364d80(%rip), %rsi # 0x6e7b00 movq %rbx, %rdi callq 0x396626 leaq 0x364c69(%rip), %rax # 0x6e79f8 movq %rax, (%rbx) leaq 0x364d4f(%rip), %rax # 0x6e7ae8 movq %rax, 0x190(%rbx) leaq 0x364c79(%rip), %rax # 0x6e7a20 movq %rax, 0x88(%rbx) leaq 0x364c93(%rip), %rax # 0x6e7a48 movq %rax, 0x98(%rbx) leaq 0x364cad(%rip), %rax # 0x6e7a70 movq %rax, 0xf0(%rbx) leaq 0x364cc7(%rip), %rax # 0x6e7a98 movq %rax, 0x148(%rbx) leaq 0x364ce1(%rip), %rax # 0x6e7ac0 movq %rax, 0x180(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x375a02 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x382e22 movq %rax, %r14 movl $0x1a8, %esi # imm = 0x1A8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcObject, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xe8, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x3632f1(%rip), %rax # 0x6e6a70 movq %rax, 0xd0(%rbx) movq $0x0, 0xd8(%rbx) leaq 0x2301cd(%rip), %rax # 0x5b3965 movq %rax, 0xe0(%rbx) leaq 0x36aa62(%rip), %rsi # 0x6ee208 movq %rbx, %rdi callq 0x394bea xorl %eax, %eax movq %rax, 0xa0(%rbx) leaq 0x36a9b2(%rip), %rcx # 0x6ee170 movq %rcx, (%rbx) leaq 0x36aa20(%rip), %rcx # 0x6ee1e8 movq %rcx, 0xd0(%rbx) leaq 0x36a9c2(%rip), %rcx # 0x6ee198 movq %rcx, 0x88(%rbx) leaq 0x36a9dc(%rip), %rcx # 0x6ee1c0 movq %rcx, 0x98(%rbx) movq %rbx, %rcx addq $0xb8, %rcx movq %rcx, 0xa8(%rbx) movq %rax, 0xb0(%rbx) movb %al, 0xb8(%rbx) movb %al, 0xc8(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x376445 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38384b movq %rax, %r14 movl $0xe8, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcTextLiteralWithExtent, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movl $0xd0, %edi callq 0x1a5230 movq %rax, %rbx movl $0xb8, %r15d leaq (%rax,%r15), %r14 leaq 0x362f0e(%rip), %rax # 0x6e6a70 movq %rax, 0xb8(%rbx) xorl %r12d, %r12d movq %r12, 0xc0(%rbx) leaq 0x232372(%rip), %rax # 0x5b5eec movq %rax, 0xc8(%rbx) leaq 0x36b5b8(%rip), %rsi # 0x6ef140 movq %rbx, %rdi callq 0x39f3c8 xorps %xmm0, %xmm0 movups %xmm0, 0x88(%rbx) leaq 0x36b4e7(%rip), %rax # 0x6ef088 movq %rax, (%rbx) leaq 0x36b4c5(%rip), %rax # 0x6ef070 addq %r15, %rax movq %rax, 0xb8(%rbx) leaq 0x36b4f4(%rip), %rax # 0x6ef0b0 movq %rax, 0x10(%rbx) leaq 0x36b511(%rip), %rax # 0x6ef0d8 movq %rax, 0x20(%rbx) leaq 0x36b52e(%rip), %rax # 0x6ef100 movq %rax, 0x80(%rbx) leaq 0xa8(%rbx), %rax movq %rax, 0x98(%rbx) movq %r12, 0xa0(%rbx) movb $0x0, 0xa8(%rbx) movq %r14, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x118, %edi # imm = 0x118 callq 0x1a5230 movq %rax, %rbx leaq 0x362da3(%rip), %rax # 0x6e6a70 movq %rax, 0x100(%rbx) movq $0x0, 0x108(%rbx) leaq 0x22fdf1(%rip), %rax # 0x5b3ad7 movq %rax, 0x110(%rbx) leaq 0x36b91c(%rip), %rsi # 0x6ef610 movq %rbx, %rdi callq 0x39e3b2 xorps %xmm0, %xmm0 movups %xmm0, 0xd8(%rbx) leaq 0x36b84b(%rip), %rax # 0x6ef558 movq %rax, (%rbx) leaq 0x36b8e1(%rip), %rax # 0x6ef5f8 movq %rax, 0x100(%rbx) leaq 0x36b85b(%rip), %rax # 0x6ef580 movq %rax, 0x88(%rbx) leaq 0x36b875(%rip), %rax # 0x6ef5a8 movq %rax, 0x98(%rbx) leaq 0x36b88f(%rip), %rax # 0x6ef5d0 movq %rax, 0xd0(%rbx) xorl %eax, %eax movb %al, 0xe8(%rbx) movq $0x0, 0xf0(%rbx) movb %al, 0xf8(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x376cbf movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x383d9d movq %rax, %r14 movl $0x118, %esi # imm = 0x118 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcDistributionElement, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x160, %edi # imm = 0x160 callq 0x1a5230 movq %rax, %rbx leaq 0x362c47(%rip), %rax # 0x6e6a70 movq %rax, 0x148(%rbx) movq $0x0, 0x150(%rbx) leaq 0x2320c3(%rip), %rax # 0x5b5f05 movq %rax, 0x158(%rbx) leaq 0x36c1d0(%rip), %rsi # 0x6f0020 movq %rbx, %rdi callq 0x3a0a42 leaq 0x36c0b9(%rip), %rax # 0x6eff18 movq %rax, (%rbx) leaq 0x36c19f(%rip), %rax # 0x6f0008 movq %rax, 0x148(%rbx) leaq 0x36c0c9(%rip), %rax # 0x6eff40 movq %rax, 0x88(%rbx) leaq 0x36c0e3(%rip), %rax # 0x6eff68 movq %rax, 0x98(%rbx) leaq 0x36c0fd(%rip), %rax # 0x6eff90 movq %rax, 0xd0(%rbx) leaq 0x36c117(%rip), %rax # 0x6effb8 movq %rax, 0x100(%rbx) leaq 0x36c131(%rip), %rax # 0x6effe0 movq %rax, 0x138(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37710c movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x383ef2 movq %rax, %r14 movl $0x160, %esi # imm = 0x160 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator, 4ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x80, %edi callq 0x1a5230 movq %rax, %rbx xorl %eax, %eax movq %rax, 0x70(%rbx) leaq 0x22f9bc(%rip), %rcx # 0x5b3c6b movq %rcx, 0x78(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0x28(%rbx) leaq 0x36e0c7(%rip), %rcx # 0x6f2388 movq %rcx, (%rbx) leaq 0x36e135(%rip), %rcx # 0x6f2400 movq %rcx, 0x68(%rbx) leaq 0x36e0da(%rip), %rcx # 0x6f23b0 movq %rcx, 0x10(%rbx) leaq 0x36e0f7(%rip), %rcx # 0x6f23d8 movq %rcx, 0x20(%rbx) movb %al, 0x38(%rbx) movq %rax, 0x40(%rbx) movb %al, 0x48(%rbx) movq %rax, 0x50(%rbx) movb %al, 0x60(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x3776b0 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcSurface, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %rax movl $0x48, %edi callq 0x1a5230 leaq 0x30(%rax), %rcx movq $0x0, 0x38(%rax) leaq 0x231821(%rip), %rdx # 0x5b5fa9 movq %rdx, 0x40(%rax) leaq 0x36f69d(%rip), %rdx # 0x6f3e30 movq %rdx, (%rax) leaq 0x36f70b(%rip), %rdx # 0x6f3ea8 movq %rdx, 0x30(%rax) leaq 0x36f6b0(%rip), %rdx # 0x6f3e58 movq %rdx, 0x10(%rax) leaq 0x36f6cd(%rip), %rdx # 0x6f3e80 movq %rdx, 0x20(%rax) movq %rcx, %rax popq %rcx retq
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcManifoldSolidBrep, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x60, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x361f63(%rip), %rax # 0x6e6a70 movq %rax, 0x48(%rbx) movq $0x0, 0x50(%rbx) leaq 0x22f567(%rip), %rax # 0x5b4087 movq %rax, 0x58(%rbx) leaq 0x3705bd(%rip), %rsi # 0x6f50e8 movq %rbx, %rdi callq 0x3a475c xorps %xmm0, %xmm0 movups %xmm0, 0x38(%rbx) leaq 0x3704ef(%rip), %rax # 0x6f5030 movq %rax, (%rbx) leaq 0x370585(%rip), %rax # 0x6f50d0 movq %rax, 0x48(%rbx) leaq 0x370502(%rip), %rax # 0x6f5058 movq %rax, 0x10(%rbx) leaq 0x37051f(%rip), %rax # 0x6f5080 movq %rax, 0x20(%rbx) leaq 0x37053c(%rip), %rax # 0x6f50a8 movq %rax, 0x30(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x378ce8 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcStackTerminalType, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1f8, %edi # imm = 0x1F8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3a5a94 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x375a02 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x384d0a movq %rax, %r14 movl $0x1f8, %esi # imm = 0x1F8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcStructuralCurveConnection, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x158, %edi # imm = 0x158 callq 0x1a5230 movq %rax, %rbx leaq 0x361b5b(%rip), %rax # 0x6e6a70 movq %rax, 0x140(%rbx) movq $0x0, 0x148(%rbx) leaq 0x2310e7(%rip), %rax # 0x5b6015 movq %rax, 0x150(%rbx) leaq 0x372dd4(%rip), %rsi # 0x6f7d10 movq %rbx, %rdi callq 0x3a751c leaq 0x372c95(%rip), %rax # 0x6f7be0 movq %rax, (%rbx) leaq 0x372da3(%rip), %rax # 0x6f7cf8 movq %rax, 0x140(%rbx) leaq 0x372ca5(%rip), %rax # 0x6f7c08 movq %rax, 0x88(%rbx) leaq 0x372cbf(%rip), %rax # 0x6f7c30 movq %rax, 0x98(%rbx) leaq 0x372cd9(%rip), %rax # 0x6f7c58 movq %rax, 0xd0(%rbx) leaq 0x372cf3(%rip), %rax # 0x6f7c80 movq %rax, 0x100(%rbx) leaq 0x372d0d(%rip), %rax # 0x6f7ca8 movq %rax, 0x110(%rbx) leaq 0x372d27(%rip), %rax # 0x6f7cd0 movq %rax, 0x130(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x376cbf movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x384fec movq %rax, %r14 movl $0x158, %esi # imm = 0x158 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcProcess, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xf8, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x36187b(%rip), %rax # 0x6e6a70 movq %rax, 0xe0(%rbx) movq $0x0, 0xe8(%rbx) leaq 0x230e37(%rip), %rax # 0x5b6045 movq %rax, 0xf0(%rbx) leaq 0x37466c(%rip), %rsi # 0x6f9888 movq %rbx, %rdi callq 0x39e3b2 leaq 0x3745a5(%rip), %rax # 0x6f97d0 movq %rax, (%rbx) leaq 0x37463b(%rip), %rax # 0x6f9870 movq %rax, 0xe0(%rbx) leaq 0x3745b5(%rip), %rax # 0x6f97f8 movq %rax, 0x88(%rbx) leaq 0x3745cf(%rip), %rax # 0x6f9820 movq %rax, 0x98(%rbx) leaq 0x3745e9(%rip), %rax # 0x6f9848 movq %rax, 0xd0(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x376445 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x3852a2 movq %rax, %r14 movl $0xf8, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcEdge, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %rax movl $0x58, %edi callq 0x1a5230 leaq 0x40(%rax), %rcx xorl %edx, %edx movq %rdx, 0x48(%rax) leaq 0x23091a(%rip), %rsi # 0x5b60ca movq %rsi, 0x50(%rax) movq %rdx, 0x28(%rax) leaq 0x377239(%rip), %rdx # 0x6fc9f8 movq %rdx, (%rax) leaq 0x3772a7(%rip), %rdx # 0x6fca70 movq %rdx, 0x40(%rax) leaq 0x37724c(%rip), %rdx # 0x6fca20 movq %rdx, 0x10(%rax) leaq 0x377269(%rip), %rdx # 0x6fca48 movq %rdx, 0x20(%rax) xorps %xmm0, %xmm0 movups %xmm0, 0x30(%rax) movq %rcx, %rax popq %rcx retq nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFlowStorageDevice, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x180, %edi # imm = 0x180 callq 0x1a5230 movq %rax, %rbx leaq 0x36104d(%rip), %rax # 0x6e6a70 movq %rax, 0x168(%rbx) movq $0x0, 0x170(%rbx) leaq 0x2306f3(%rip), %rax # 0x5b612f movq %rax, 0x178(%rbx) leaq 0x378f1e(%rip), %rsi # 0x6fe968 movq %rbx, %rdi callq 0x3ad4d0 leaq 0x378db7(%rip), %rax # 0x6fe810 movq %rax, (%rbx) leaq 0x378eed(%rip), %rax # 0x6fe950 movq %rax, 0x168(%rbx) leaq 0x378dc7(%rip), %rax # 0x6fe838 movq %rax, 0x88(%rbx) leaq 0x378de1(%rip), %rax # 0x6fe860 movq %rax, 0x98(%rbx) leaq 0x378dfb(%rip), %rax # 0x6fe888 movq %rax, 0xd0(%rbx) leaq 0x378e15(%rip), %rax # 0x6fe8b0 movq %rax, 0x100(%rbx) leaq 0x378e2f(%rip), %rax # 0x6fe8d8 movq %rax, 0x138(%rbx) leaq 0x378e49(%rip), %rax # 0x6fe900 movq %rax, 0x148(%rbx) leaq 0x378e63(%rip), %rax # 0x6fe928 movq %rax, 0x158(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37710c movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x385b08 movq %rax, %r14 movl $0x180, %esi # imm = 0x180 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x70, %edi callq 0x1a5230 movq %rax, %rbx xorl %eax, %eax movq %rax, 0x60(%rbx) leaq 0x22e5b2(%rip), %rcx # 0x5b4373 movq %rcx, 0x68(%rbx) movq %rax, 0x8(%rbx) leaq 0x37a5e0(%rip), %rcx # 0x7003b0 movq %rcx, (%rbx) leaq 0x37a5fe(%rip), %rcx # 0x7003d8 movq %rcx, 0x58(%rbx) leaq 0x20(%rbx), %rcx movq %rcx, 0x10(%rbx) movq %rax, 0x18(%rbx) movb %al, 0x20(%rbx) leaq 0x40(%rbx), %rcx movq %rcx, 0x30(%rbx) movq %rax, 0x38(%rbx) movb %al, 0x40(%rbx) movb %al, 0x50(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x379b5c movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcCShapeProfileDef, 6ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xd8, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x360b75(%rip), %rax # 0x6e6a70 movq %rax, 0xc0(%rbx) movq $0x0, 0xc8(%rbx) leaq 0x230267(%rip), %rax # 0x5b617b movq %rax, 0xd0(%rbx) leaq 0x37a6d6(%rip), %rsi # 0x7005f8 movq %rbx, %rdi callq 0x3ae2ec movq $0x0, 0x78(%rbx) leaq 0x37a62f(%rip), %rax # 0x700568 movq %rax, (%rbx) leaq 0x37a69d(%rip), %rax # 0x7005e0 movq %rax, 0xc0(%rbx) leaq 0x37a63f(%rip), %rax # 0x700590 movq %rax, 0x58(%rbx) leaq 0x37a65c(%rip), %rax # 0x7005b8 movq %rax, 0x70(%rbx) xorl %eax, %eax movb %al, 0xa8(%rbx) movb %al, 0xb8(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x379f69 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x385faa movq %rax, %r14 movl $0xd8, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcBuildingElement, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x160, %edi # imm = 0x160 callq 0x1a5230 movq %rax, %rbx leaq 0x3607e9(%rip), %rax # 0x6e6a70 movq %rax, 0x148(%rbx) movq $0x0, 0x150(%rbx) leaq 0x22e25e(%rip), %rax # 0x5b44fe movq %rax, 0x158(%rbx) leaq 0x37d0f2(%rip), %rsi # 0x7033a0 movq %rbx, %rdi callq 0x3a0a42 leaq 0x37cfdb(%rip), %rax # 0x703298 movq %rax, (%rbx) leaq 0x37d0c1(%rip), %rax # 0x703388 movq %rax, 0x148(%rbx) leaq 0x37cfeb(%rip), %rax # 0x7032c0 movq %rax, 0x88(%rbx) leaq 0x37d005(%rip), %rax # 0x7032e8 movq %rax, 0x98(%rbx) leaq 0x37d01f(%rip), %rax # 0x703310 movq %rax, 0xd0(%rbx) leaq 0x37d039(%rip), %rax # 0x703338 movq %rax, 0x100(%rbx) leaq 0x37d053(%rip), %rax # 0x703360 movq %rax, 0x138(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37a38d movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x386350 movq %rax, %r14 movl $0x160, %esi # imm = 0x160 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcCraneRailAShapeProfileDef, 12ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x108, %edi # imm = 0x108 callq 0x1a5230 movq %rax, %rbx leaq 0x3602ed(%rip), %rax # 0x6e6a70 movq %rax, 0xf0(%rbx) movq $0x0, 0xf8(%rbx) leaq 0x22fa8b(%rip), %rax # 0x5b6227 movq %rax, 0x100(%rbx) leaq 0x38089e(%rip), %rsi # 0x707048 movq %rbx, %rdi callq 0x3ae2ec movq $0x0, 0x78(%rbx) leaq 0x3807f7(%rip), %rax # 0x706fb8 movq %rax, (%rbx) leaq 0x380865(%rip), %rax # 0x707030 movq %rax, 0xf0(%rbx) leaq 0x380807(%rip), %rax # 0x706fe0 movq %rax, 0x58(%rbx) leaq 0x380824(%rip), %rax # 0x707008 movq %rax, 0x70(%rbx) xorl %eax, %eax movb %al, 0x98(%rbx) movb %al, 0xe8(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x379f69 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x386832 movq %rax, %r14 movl $0x108, %esi # imm = 0x108 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcCircleHollowProfileDef, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xb8, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x3600eb(%rip), %rax # 0x6e6a70 movq %rax, 0xa0(%rbx) movq $0x0, 0xa8(%rbx) leaq 0x22dc08(%rip), %rax # 0x5b45a6 movq %rax, 0xb0(%rbx) leaq 0x381b04(%rip), %rsi # 0x7084b0 movq %rbx, %rdi callq 0x3b233a movq $0x0, 0x90(%rbx) leaq 0x381a32(%rip), %rax # 0x7083f8 movq %rax, (%rbx) leaq 0x381ac8(%rip), %rax # 0x708498 movq %rax, 0xa0(%rbx) leaq 0x381a42(%rip), %rax # 0x708420 movq %rax, 0x58(%rbx) leaq 0x381a5f(%rip), %rax # 0x708448 movq %rax, 0x70(%rbx) leaq 0x381a7c(%rip), %rax # 0x708470 movq %rax, 0x88(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37a72a movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x386a37 movq %rax, %r14 movl $0xb8, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xa8, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35fc83(%rip), %rax # 0x6e6a70 movq %rax, 0x90(%rbx) movq $0x0, 0x98(%rbx) leaq 0x22dac1(%rip), %rax # 0x5b48c7 movq %rax, 0xa0(%rbx) leaq 0x3829b4(%rip), %rsi # 0x7097c8 movq %rbx, %rdi callq 0x3ae2ec movq $0x0, 0x78(%rbx) leaq 0x38290d(%rip), %rax # 0x709738 movq %rax, (%rbx) leaq 0x38297b(%rip), %rax # 0x7097b0 movq %rax, 0x90(%rbx) leaq 0x38291d(%rip), %rax # 0x709760 movq %rax, 0x58(%rbx) leaq 0x38293a(%rip), %rax # 0x709788 movq %rax, 0x70(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37b752 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x386e8e movq %rax, %r14 movl $0xa8, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcDimensionCurveDirectedCallout, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r14 pushq %rbx pushq %rax movl $0x70, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35f99c(%rip), %rax # 0x6e6a70 movq %rax, 0x58(%rbx) movq $0x0, 0x60(%rbx) leaq 0x22f1e7(%rip), %rax # 0x5b62ce movq %rax, 0x68(%rbx) leaq 0x3849ee(%rip), %rsi # 0x70bae0 movq %rbx, %rdi callq 0x3b5422 movq %rbx, %rax addq $0x58, %rax leaq 0x384920(%rip), %rcx # 0x70ba28 movq %rcx, (%rbx) leaq 0x3849b6(%rip), %rcx # 0x70bac8 movq %rcx, 0x58(%rbx) leaq 0x384933(%rip), %rcx # 0x70ba50 movq %rcx, 0x10(%rbx) leaq 0x384950(%rip), %rcx # 0x70ba78 movq %rcx, 0x20(%rbx) leaq 0x38496d(%rip), %rcx # 0x70baa0 movq %rcx, 0x48(%rbx) addq $0x8, %rsp popq %rbx popq %r14 retq movq %rax, %r14 movl $0x70, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptDiskSolid, 5ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x88, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35f1bf(%rip), %rax # 0x6e6a70 movq %rax, 0x70(%rbx) movq $0x0, 0x78(%rbx) leaq 0x22d2cb(%rip), %rax # 0x5b4b8f movq %rax, 0x80(%rbx) leaq 0x388376(%rip), %rsi # 0x70fc48 movq %rbx, %rdi callq 0x3a475c xorps %xmm0, %xmm0 movups %xmm0, 0x38(%rbx) leaq 0x3882a8(%rip), %rax # 0x70fb90 movq %rax, (%rbx) leaq 0x38833e(%rip), %rax # 0x70fc30 movq %rax, 0x70(%rbx) leaq 0x3882bb(%rip), %rax # 0x70fbb8 movq %rax, 0x10(%rbx) leaq 0x3882d8(%rip), %rax # 0x70fbe0 movq %rax, 0x20(%rbx) leaq 0x3882f5(%rip), %rax # 0x70fc08 movq %rax, 0x30(%rbx) movb $0x0, 0x58(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37c60c movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcValveType, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1f8, %edi # imm = 0x1F8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3bb690 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x375a02 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x387fc8 movq %rax, %r14 movl $0x1f8, %esi # imm = 0x1F8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcActor, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x108, %edi # imm = 0x108 callq 0x1a5230 movq %rax, %rbx leaq 0x35e85f(%rip), %rax # 0x6e6a70 movq %rax, 0xf0(%rbx) movq $0x0, 0xf8(%rbx) leaq 0x22e21a(%rip), %rax # 0x5b6444 movq %rax, 0x100(%rbx) leaq 0x38f0a0(%rip), %rsi # 0x7172d8 movq %rbx, %rdi callq 0x39e3b2 movq $0x0, 0xd8(%rbx) leaq 0x38efce(%rip), %rax # 0x717220 movq %rax, (%rbx) leaq 0x38f064(%rip), %rax # 0x7172c0 movq %rax, 0xf0(%rbx) leaq 0x38efde(%rip), %rax # 0x717248 movq %rax, 0x88(%rbx) leaq 0x38eff8(%rip), %rax # 0x717270 movq %rax, 0x98(%rbx) leaq 0x38f012(%rip), %rax # 0x717298 movq %rax, 0xd0(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0xe0(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x376445 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x3882d3 movq %rax, %r14 movl $0x108, %esi # imm = 0x108 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcReinforcingElement, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1a8, %edi # imm = 0x1A8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3c0c70 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37a38d movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x388c2c movq %rax, %r14 movl $0x1a8, %esi # imm = 0x1A8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcTShapeProfileDef, 10ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x118, %edi # imm = 0x118 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3c24f4 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x379f69 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x388d58 movq %rax, %r14 movl $0x118, %esi # imm = 0x118 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xe0, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35d81f(%rip), %rax # 0x6e6a70 movq %rax, 0xc8(%rbx) movq $0x0, 0xd0(%rbx) leaq 0x22c074(%rip), %rax # 0x5b52de movq %rax, 0xd8(%rbx) leaq 0x39b020(%rip), %rsi # 0x724298 movq %rbx, %rdi callq 0x394bea movq $0x0, 0xa0(%rbx) leaq 0x39af6e(%rip), %rax # 0x724200 movq %rax, (%rbx) leaq 0x39afdc(%rip), %rax # 0x724278 movq %rax, 0xc8(%rbx) leaq 0x39af7e(%rip), %rax # 0x724228 movq %rax, 0x88(%rbx) leaq 0x39af98(%rip), %rax # 0x724250 movq %rax, 0x98(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0xa8(%rbx) movups %xmm0, 0xb8(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37ed16 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38930c movq %rax, %r14 movl $0xe0, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFastener, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x170, %edi # imm = 0x170 callq 0x1a5230 movq %rax, %rbx leaq 0x35d4b9(%rip), %rax # 0x6e6a70 movq %rax, 0x158(%rbx) movq $0x0, 0x160(%rbx) leaq 0x22d090(%rip), %rax # 0x5b6660 movq %rax, 0x168(%rbx) leaq 0x39c862(%rip), %rsi # 0x725e40 movq %rbx, %rdi callq 0x3c5d04 leaq 0x39c723(%rip), %rax # 0x725d10 movq %rax, (%rbx) leaq 0x39c831(%rip), %rax # 0x725e28 movq %rax, 0x158(%rbx) leaq 0x39c733(%rip), %rax # 0x725d38 movq %rax, 0x88(%rbx) leaq 0x39c74d(%rip), %rax # 0x725d60 movq %rax, 0x98(%rbx) leaq 0x39c767(%rip), %rax # 0x725d88 movq %rax, 0xd0(%rbx) leaq 0x39c781(%rip), %rax # 0x725db0 movq %rax, 0x100(%rbx) leaq 0x39c79b(%rip), %rax # 0x725dd8 movq %rax, 0x138(%rbx) leaq 0x39c7b5(%rip), %rax # 0x725e00 movq %rax, 0x148(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37710c movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38968e movq %rax, %r14 movl $0x170, %esi # imm = 0x170 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcCrewResource, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1a0, %edi # imm = 0x1A0 callq 0x1a5230 movq %rax, %rbx leaq 0x35d291(%rip), %rax # 0x6e6a70 movq %rax, 0x188(%rbx) movq $0x0, 0x190(%rbx) leaq 0x22ce8a(%rip), %rax # 0x5b6682 movq %rax, 0x198(%rbx) leaq 0x39d49a(%rip), %rsi # 0x726ca0 movq %rbx, %rdi callq 0x3ab3e0 leaq 0x39d383(%rip), %rax # 0x726b98 movq %rax, (%rbx) leaq 0x39d469(%rip), %rax # 0x726c88 movq %rax, 0x188(%rbx) leaq 0x39d393(%rip), %rax # 0x726bc0 movq %rax, 0x88(%rbx) leaq 0x39d3ad(%rip), %rax # 0x726be8 movq %rax, 0x98(%rbx) leaq 0x39d3c7(%rip), %rax # 0x726c10 movq %rax, 0xd0(%rbx) leaq 0x39d3e1(%rip), %rax # 0x726c38 movq %rax, 0xe0(%rbx) leaq 0x39d3fb(%rip), %rax # 0x726c60 movq %rax, 0x178(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x376445 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x3898a8 movq %rax, %r14 movl $0x1a0, %esi # imm = 0x1A0 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcAirTerminalType, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1f8, %edi # imm = 0x1F8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3ca13e movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x375a02 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38a248 movq %rax, %r14 movl $0x1f8, %esi # imm = 0x1F8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFlowMovingDeviceType, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1c8, %edi # imm = 0x1C8 callq 0x1a5230 movq %rax, %rbx leaq 0x35c801(%rip), %rax # 0x6e6a70 movq %rax, 0x1b0(%rbx) movq $0x0, 0x1b8(%rbx) leaq 0x22c4d9(%rip), %rax # 0x5b6761 movq %rax, 0x1c0(%rbx) leaq 0x3a303a(%rip), %rsi # 0x72d2d0 movq %rbx, %rdi callq 0x3985c2 leaq 0x3a2ed3(%rip), %rax # 0x72d178 movq %rax, (%rbx) leaq 0x3a3009(%rip), %rax # 0x72d2b8 movq %rax, 0x1b0(%rbx) leaq 0x3a2ee3(%rip), %rax # 0x72d1a0 movq %rax, 0x88(%rbx) leaq 0x3a2efd(%rip), %rax # 0x72d1c8 movq %rax, 0x98(%rbx) leaq 0x3a2f17(%rip), %rax # 0x72d1f0 movq %rax, 0xf0(%rbx) leaq 0x3a2f31(%rip), %rax # 0x72d218 movq %rax, 0x148(%rbx) leaq 0x3a2f4b(%rip), %rax # 0x72d240 movq %rax, 0x180(%rbx) leaq 0x3a2f65(%rip), %rax # 0x72d268 movq %rax, 0x190(%rbx) leaq 0x3a2f7f(%rip), %rax # 0x72d290 movq %rax, 0x1a0(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x375a02 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38a354 movq %rax, %r14 movl $0x1c8, %esi # imm = 0x1C8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcWall, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x170, %edi # imm = 0x170 callq 0x1a5230 movq %rax, %rbx leaq 0x35c1b1(%rip), %rax # 0x6e6a70 movq %rax, 0x158(%rbx) movq $0x0, 0x160(%rbx) leaq 0x22bf33(%rip), %rax # 0x5b680b movq %rax, 0x168(%rbx) leaq 0x3a755a(%rip), %rsi # 0x731e40 movq %rbx, %rdi callq 0x3af3f0 leaq 0x3a741b(%rip), %rax # 0x731d10 movq %rax, (%rbx) leaq 0x3a7529(%rip), %rax # 0x731e28 movq %rax, 0x158(%rbx) leaq 0x3a742b(%rip), %rax # 0x731d38 movq %rax, 0x88(%rbx) leaq 0x3a7445(%rip), %rax # 0x731d60 movq %rax, 0x98(%rbx) leaq 0x3a745f(%rip), %rax # 0x731d88 movq %rax, 0xd0(%rbx) leaq 0x3a7479(%rip), %rax # 0x731db0 movq %rax, 0x100(%rbx) leaq 0x3a7493(%rip), %rax # 0x731dd8 movq %rax, 0x138(%rbx) leaq 0x3a74ad(%rip), %rax # 0x731e00 movq %rax, 0x148(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37a38d movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38a996 movq %rax, %r14 movl $0x170, %esi # imm = 0x170 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcStructuralPointConnection, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x158, %edi # imm = 0x158 callq 0x1a5230 movq %rax, %rbx leaq 0x35c0b3(%rip), %rax # 0x6e6a70 movq %rax, 0x140(%rbx) movq $0x0, 0x148(%rbx) leaq 0x22be3d(%rip), %rax # 0x5b6813 movq %rax, 0x150(%rbx) leaq 0x3a7dec(%rip), %rsi # 0x7327d0 movq %rbx, %rdi callq 0x3a751c leaq 0x3a7cad(%rip), %rax # 0x7326a0 movq %rax, (%rbx) leaq 0x3a7dbb(%rip), %rax # 0x7327b8 movq %rax, 0x140(%rbx) leaq 0x3a7cbd(%rip), %rax # 0x7326c8 movq %rax, 0x88(%rbx) leaq 0x3a7cd7(%rip), %rax # 0x7326f0 movq %rax, 0x98(%rbx) leaq 0x3a7cf1(%rip), %rax # 0x732718 movq %rax, 0xd0(%rbx) leaq 0x3a7d0b(%rip), %rax # 0x732740 movq %rax, 0x100(%rbx) leaq 0x3a7d25(%rip), %rax # 0x732768 movq %rax, 0x110(%rbx) leaq 0x3a7d3f(%rip), %rax # 0x732790 movq %rax, 0x130(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x376cbf movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38aa94 movq %rax, %r14 movl $0x158, %esi # imm = 0x158 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcAnnotationOccurrence, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x98, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35bc8b(%rip), %rax # 0x6e6a70 movq %rax, 0x80(%rbx) movq $0x0, 0x88(%rbx) leaq 0x22ba60(%rip), %rax # 0x5b685e movq %rax, 0x90(%rbx) leaq 0x3aa3cc(%rip), %rsi # 0x7351d8 movq %rbx, %rdi callq 0x3d0e5c leaq 0x3aa32d(%rip), %rax # 0x735148 movq %rax, (%rbx) leaq 0x3aa39b(%rip), %rax # 0x7351c0 movq %rax, 0x80(%rbx) leaq 0x3aa33d(%rip), %rax # 0x735170 movq %rax, 0x10(%rbx) leaq 0x3aa35a(%rip), %rax # 0x735198 movq %rax, 0x70(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x381958 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38ae7e movq %rax, %r14 movl $0x98, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcAnnotationSymbolOccurrence, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xa8, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35bbcb(%rip), %rax # 0x6e6a70 movq %rax, 0x90(%rbx) movq $0x0, 0x98(%rbx) leaq 0x22b9b8(%rip), %rax # 0x5b6876 movq %rax, 0xa0(%rbx) leaq 0x3aa66c(%rip), %rsi # 0x735538 movq %rbx, %rdi callq 0x3d0e5c leaq 0x3aa59d(%rip), %rax # 0x735478 movq %rax, (%rbx) leaq 0x3aa633(%rip), %rax # 0x735518 movq %rax, 0x90(%rbx) leaq 0x3aa5ad(%rip), %rax # 0x7354a0 movq %rax, 0x10(%rbx) leaq 0x3aa5ca(%rip), %rax # 0x7354c8 movq %rax, 0x70(%rbx) leaq 0x3aa5e7(%rip), %rax # 0x7354f0 movq %rax, 0x80(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x381958 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38af4c movq %rax, %r14 movl $0xa8, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcAlarmType, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1e8, %edi # imm = 0x1E8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3d3ab6 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x375a02 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38b446 movq %rax, %r14 movl $0x1e8, %esi # imm = 0x1E8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcEllipseProfileDef, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xa8, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35b603(%rip), %rax # 0x6e6a70 movq %rax, 0x90(%rbx) movq $0x0, 0x98(%rbx) leaq 0x22b464(%rip), %rax # 0x5b68ea movq %rax, 0xa0(%rbx) leaq 0x3ad5bc(%rip), %rsi # 0x738a50 movq %rbx, %rdi callq 0x3ae2ec movq $0x0, 0x78(%rbx) leaq 0x3ad515(%rip), %rax # 0x7389c0 movq %rax, (%rbx) leaq 0x3ad583(%rip), %rax # 0x738a38 movq %rax, 0x90(%rbx) leaq 0x3ad525(%rip), %rax # 0x7389e8 movq %rax, 0x58(%rbx) leaq 0x3ad542(%rip), %rax # 0x738a10 movq %rax, 0x70(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x379f69 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38b50e movq %rax, %r14 movl $0xa8, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcStair, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x190, %edi # imm = 0x190 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3d4242 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37a38d movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38b572 movq %rax, %r14 movl $0x190, %esi # imm = 0x190 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFlowFitting, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x180, %edi # imm = 0x180 callq 0x1a5230 movq %rax, %rbx leaq 0x35b09f(%rip), %rax # 0x6e6a70 movq %rax, 0x168(%rbx) movq $0x0, 0x170(%rbx) leaq 0x22af7d(%rip), %rax # 0x5b6967 movq %rax, 0x178(%rbx) leaq 0x3b0a30(%rip), %rsi # 0x73c428 movq %rbx, %rdi callq 0x3ad4d0 leaq 0x3b08c9(%rip), %rax # 0x73c2d0 movq %rax, (%rbx) leaq 0x3b09ff(%rip), %rax # 0x73c410 movq %rax, 0x168(%rbx) leaq 0x3b08d9(%rip), %rax # 0x73c2f8 movq %rax, 0x88(%rbx) leaq 0x3b08f3(%rip), %rax # 0x73c320 movq %rax, 0x98(%rbx) leaq 0x3b090d(%rip), %rax # 0x73c348 movq %rax, 0xd0(%rbx) leaq 0x3b0927(%rip), %rax # 0x73c370 movq %rax, 0x100(%rbx) leaq 0x3b0941(%rip), %rax # 0x73c398 movq %rax, 0x138(%rbx) leaq 0x3b095b(%rip), %rax # 0x73c3c0 movq %rax, 0x148(%rbx) leaq 0x3b0975(%rip), %rax # 0x73c3e8 movq %rax, 0x158(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x37710c movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38bab6 movq %rax, %r14 movl $0x180, %esi # imm = 0x180 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcWorkControl, 10ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x218, %edi # imm = 0x218 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3d9398 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41d62f movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38bf2c movq %rax, %r14 movl $0x218, %esi # imm = 0x218 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcWorkSchedule, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x228, %edi # imm = 0x228 callq 0x1a5230 movq %rax, %rbx leaq 0x35ab1d(%rip), %rax # 0x6e6a70 movq %rax, 0x210(%rbx) movq $0x0, 0x218(%rbx) leaq 0x22aa6c(%rip), %rax # 0x5b69d8 movq %rax, 0x220(%rbx) leaq 0x3b2ff6(%rip), %rsi # 0x73ef70 movq %rbx, %rdi callq 0x3d9838 leaq 0x3b2edf(%rip), %rax # 0x73ee68 movq %rax, (%rbx) leaq 0x3b2fc5(%rip), %rax # 0x73ef58 movq %rax, 0x210(%rbx) leaq 0x3b2eef(%rip), %rax # 0x73ee90 movq %rax, 0x88(%rbx) leaq 0x3b2f09(%rip), %rax # 0x73eeb8 movq %rax, 0x98(%rbx) leaq 0x3b2f23(%rip), %rax # 0x73eee0 movq %rax, 0xd0(%rbx) leaq 0x3b2f3d(%rip), %rax # 0x73ef08 movq %rax, 0xe0(%rbx) leaq 0x3b2f57(%rip), %rax # 0x73ef30 movq %rax, 0x200(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41d634 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38c01c movq %rax, %r14 movl $0x228, %esi # imm = 0x228 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFace, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x60, %edi callq 0x1a5230 movq %rax, %rbx xorl %eax, %eax movq %rax, 0x50(%rbx) leaq 0x2374a9(%rip), %rcx # 0x5c3556 movq %rcx, 0x58(%rbx) movq %rax, 0x28(%rbx) leaq 0x3b433c(%rip), %rcx # 0x7403f8 movq %rcx, (%rbx) leaq 0x3b43aa(%rip), %rcx # 0x740470 movq %rcx, 0x48(%rbx) leaq 0x3b434f(%rip), %rcx # 0x740420 movq %rcx, 0x10(%rbx) leaq 0x3b436c(%rip), %rcx # 0x740448 movq %rcx, 0x20(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0x30(%rbx) movq %rax, 0x40(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41d63e movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcStructuralSurfaceMemberVarying, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1a8, %edi # imm = 0x1A8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3da826 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41d8bc movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38c1de movq %rax, %r14 movl $0x1a8, %esi # imm = 0x1A8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcPlanarBox, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rsi, %r14 movq %rdi, %r15 movl $0x78, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35a690(%rip), %rax # 0x6e6a70 movq %rax, 0x60(%rbx) xorl %r12d, %r12d movq %r12, 0x68(%rbx) leaq 0x22a675(%rip), %rax # 0x5b6a67 movq %rax, 0x70(%rbx) leaq 0x3b6263(%rip), %rsi # 0x742660 movq %rbx, %rdi callq 0x3dc1cc movq %r12, 0x48(%rbx) leaq 0x3b6198(%rip), %rax # 0x7425a8 movq %rax, (%rbx) leaq 0x3b622e(%rip), %rax # 0x742648 movq %rax, 0x60(%rbx) leaq 0x3b61ab(%rip), %rax # 0x7425d0 movq %rax, 0x10(%rbx) leaq 0x3b61c8(%rip), %rax # 0x7425f8 movq %rax, 0x20(%rbx) leaq 0x3b61e5(%rip), %rax # 0x742620 movq %rax, 0x40(%rbx) xorps %xmm0, %xmm0 movups %xmm0, 0x50(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41d8d0 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcStructuralPlanarAction, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1c0, %edi # imm = 0x1C0 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3dca36 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41e42e movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38c784 movq %rax, %r14 movl $0x1c0, %esi # imm = 0x1C0 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcStructuralPlanarActionVarying, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1f0, %edi # imm = 0x1F0 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3ddd8a movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41e433 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38c7e8 movq %rax, %r14 movl $0x1f0, %esi # imm = 0x1F0 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcDistributionChamberElementType, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1e8, %edi # imm = 0x1E8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3e09ec movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41ed04 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38ca76 movq %rax, %r14 movl $0x1e8, %esi # imm = 0x1E8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcCenterLineProfileDef, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xa0, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x359db1(%rip), %rax # 0x6e6a70 movq %rax, 0x88(%rbx) movq $0x0, 0x90(%rbx) leaq 0x229e98(%rip), %rax # 0x5b6b70 movq %rax, 0x98(%rbx) leaq 0x3bd19a(%rip), %rsi # 0x749e80 movq %rbx, %rdi callq 0x3e1816 movq $0x0, 0x78(%rbx) leaq 0x3bd0f3(%rip), %rax # 0x749df0 movq %rax, (%rbx) leaq 0x3bd161(%rip), %rax # 0x749e68 movq %rax, 0x88(%rbx) leaq 0x3bd103(%rip), %rax # 0x749e18 movq %rax, 0x58(%rbx) leaq 0x3bd120(%rip), %rax # 0x749e40 movq %rax, 0x70(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41ed18 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38cd60 movq %rax, %r14 movl $0xa0, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcLightSourceGoniometric, 6ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x100, %edi # imm = 0x100 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3e1f62 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41ed22 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38ce28 movq %rax, %r14 movl $0x100, %esi # imm = 0x100 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcSurfaceOfLinearExtrusion, 2ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x88, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x359b59(%rip), %rax # 0x6e6a70 movq %rax, 0x70(%rbx) movq $0x0, 0x78(%rbx) leaq 0x229ca8(%rip), %rax # 0x5b6bd2 movq %rax, 0x80(%rbx) leaq 0x3bf4b8(%rip), %rsi # 0x74c3f0 movq %rbx, %rdi callq 0x3ad810 xorps %xmm0, %xmm0 movups %xmm0, 0x58(%rbx) leaq 0x3bf3c2(%rip), %rax # 0x74c310 movq %rax, (%rbx) leaq 0x3bf480(%rip), %rax # 0x74c3d8 movq %rax, 0x70(%rbx) leaq 0x3bf3d5(%rip), %rax # 0x74c338 movq %rax, 0x10(%rbx) leaq 0x3bf3f2(%rip), %rax # 0x74c360 movq %rax, 0x20(%rbx) leaq 0x3bf40f(%rip), %rax # 0x74c388 movq %rax, 0x30(%rbx) leaq 0x3bf42c(%rip), %rax # 0x74c3b0 movq %rax, 0x50(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41ed31 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38cfc4 movq %rax, %r14 movl $0x88, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcMotorConnectionType, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1f8, %edi # imm = 0x1F8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3e3182 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41ed36 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38d028 movq %rax, %r14 movl $0x1f8, %esi # imm = 0x1F8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFlowTreatmentDeviceType, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1c8, %edi # imm = 0x1C8 callq 0x1a5230 movq %rax, %rbx leaq 0x359a21(%rip), %rax # 0x6e6a70 movq %rax, 0x1b0(%rbx) movq $0x0, 0x1b8(%rbx) leaq 0x229b9d(%rip), %rax # 0x5b6c05 movq %rax, 0x1c0(%rbx) leaq 0x3c07d2(%rip), %rsi # 0x74d848 movq %rbx, %rdi callq 0x3985c2 leaq 0x3c066b(%rip), %rax # 0x74d6f0 movq %rax, (%rbx) leaq 0x3c07a1(%rip), %rax # 0x74d830 movq %rax, 0x1b0(%rbx) leaq 0x3c067b(%rip), %rax # 0x74d718 movq %rax, 0x88(%rbx) leaq 0x3c0695(%rip), %rax # 0x74d740 movq %rax, 0x98(%rbx) leaq 0x3c06af(%rip), %rax # 0x74d768 movq %rax, 0xf0(%rbx) leaq 0x3c06c9(%rip), %rax # 0x74d790 movq %rax, 0x148(%rbx) leaq 0x3c06e3(%rip), %rax # 0x74d7b8 movq %rax, 0x180(%rbx) leaq 0x3c06fd(%rip), %rax # 0x74d7e0 movq %rax, 0x190(%rbx) leaq 0x3c0717(%rip), %rax # 0x74d808 movq %rax, 0x1a0(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41ed3b movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38d134 movq %rax, %r14 movl $0x1c8, %esi # imm = 0x1C8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcDuctSilencerType, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1f8, %edi # imm = 0x1F8 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3e48b6 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41ed40 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38d198 movq %rax, %r14 movl $0x1f8, %esi # imm = 0x1F8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcDistributionControlElement, 1ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x198, %edi # imm = 0x198 callq 0x1a5230 movq %rax, %rbx movq %rax, %rdi callq 0x3e8956 movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x41f3f5 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38d5fa movq %rax, %r14 movl $0x198, %esi # imm = 0x198 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFlowStorageDeviceType, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x1c8, %edi # imm = 0x1C8 callq 0x1a5230 movq %rax, %rbx leaq 0x358b6d(%rip), %rax # 0x6e6a70 movq %rax, 0x1b0(%rbx) movq $0x0, 0x1b8(%rbx) leaq 0x228e1b(%rip), %rax # 0x5b6d37 movq %rax, 0x1c0(%rbx) leaq 0x3c8dee(%rip), %rsi # 0x756d18 movq %rbx, %rdi callq 0x3985c2 leaq 0x3c8c87(%rip), %rax # 0x756bc0 movq %rax, (%rbx) leaq 0x3c8dbd(%rip), %rax # 0x756d00 movq %rax, 0x1b0(%rbx) leaq 0x3c8c97(%rip), %rax # 0x756be8 movq %rax, 0x88(%rbx) leaq 0x3c8cb1(%rip), %rax # 0x756c10 movq %rax, 0x98(%rbx) leaq 0x3c8ccb(%rip), %rax # 0x756c38 movq %rax, 0xf0(%rbx) leaq 0x3c8ce5(%rip), %rax # 0x756c60 movq %rax, 0x148(%rbx) leaq 0x3c8cff(%rip), %rax # 0x756c88 movq %rax, 0x180(%rbx) leaq 0x3c8d19(%rip), %rax # 0x756cb0 movq %rax, 0x190(%rbx) leaq 0x3c8d33(%rip), %rax # 0x756cd8 movq %rax, 0x1a0(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x4202d9 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38dfe8 movq %rax, %r14 movl $0x1c8, %esi # imm = 0x1C8 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcFlowTreatmentDevice, 0ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0x180, %edi # imm = 0x180 callq 0x1a5230 movq %rax, %rbx leaq 0x3588cf(%rip), %rax # 0x6e6a70 movq %rax, 0x168(%rbx) movq $0x0, 0x170(%rbx) leaq 0x228bcc(%rip), %rax # 0x5b6d86 movq %rax, 0x178(%rbx) leaq 0x3cb460(%rip), %rsi # 0x759628 movq %rbx, %rdi callq 0x3ad4d0 leaq 0x3cb2f9(%rip), %rax # 0x7594d0 movq %rax, (%rbx) leaq 0x3cb42f(%rip), %rax # 0x759610 movq %rax, 0x168(%rbx) leaq 0x3cb309(%rip), %rax # 0x7594f8 movq %rax, 0x88(%rbx) leaq 0x3cb323(%rip), %rax # 0x759520 movq %rax, 0x98(%rbx) leaq 0x3cb33d(%rip), %rax # 0x759548 movq %rax, 0xd0(%rbx) leaq 0x3cb357(%rip), %rax # 0x759570 movq %rax, 0x100(%rbx) leaq 0x3cb371(%rip), %rax # 0x759598 movq %rax, 0x138(%rbx) leaq 0x3cb38b(%rip), %rax # 0x7595c0 movq %rax, 0x148(%rbx) leaq 0x3cb3a5(%rip), %rax # 0x7595e8 movq %rax, 0x158(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x4202ed movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38e286 movq %rax, %r14 movl $0x180, %esi # imm = 0x180 movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h
Assimp::STEP::ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleHollowProfileDef, 3ul>::Construct(Assimp::STEP::DB const&, Assimp::STEP::EXPRESS::LIST const&)
static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) { // make sure we don't leak if Fill() throws an exception std::unique_ptr<TDerived> impl(new TDerived()); // GenericFill<T> is undefined so we need to have a specialization const size_t num_args = GenericFill<TDerived>(db,params,&*impl); (void)num_args; // the following check is commented because it will always trigger if // parts of the entities are generated with dummy wrapper code. // This is currently done to reduce the size of the loader // code. //if (num_args != params.GetSize() && impl->GetClassName() != "NotImplemented") { // DefaultLogger::get()->debug("STEP: not all parameters consumed"); //} return impl.release(); }
pushq %r15 pushq %r14 pushq %rbx movq %rsi, %r14 movq %rdi, %r15 movl $0xe0, %edi callq 0x1a5230 movq %rax, %rbx leaq 0x35875f(%rip), %rax # 0x6e6a70 movq %rax, 0xc8(%rbx) movq $0x0, 0xd0(%rbx) leaq 0x228a82(%rip), %rax # 0x5b6dac movq %rax, 0xd8(%rbx) leaq 0x3ccbd0(%rip), %rsi # 0x75af08 movq %rbx, %rdi callq 0x3c9d3e movq $0x0, 0x98(%rbx) leaq 0x3ccafe(%rip), %rax # 0x75ae50 movq %rax, (%rbx) leaq 0x3ccb94(%rip), %rax # 0x75aef0 movq %rax, 0xc8(%rbx) leaq 0x3ccb0e(%rip), %rax # 0x75ae78 movq %rax, 0x58(%rbx) leaq 0x3ccb2b(%rip), %rax # 0x75aea0 movq %rax, 0x70(%rbx) leaq 0x3ccb48(%rip), %rax # 0x75aec8 movq %rax, 0x90(%rbx) xorl %eax, %eax movb %al, 0xb0(%rbx) movb %al, 0xc0(%rbx) movq %r15, %rdi movq %r14, %rsi movq %rbx, %rdx callq 0x4202f7 movq (%rbx), %rax movq -0x18(%rax), %rax addq %rbx, %rax popq %rbx popq %r14 popq %r15 retq movq %rax, %r14 movq (%rbx), %rax movq %rbx, %rdi callq *0x8(%rax) jmp 0x38e3d1 movq %rax, %r14 movl $0xe0, %esi movq %rbx, %rdi callq 0x1a5190 movq %r14, %rdi callq 0x1a5b90 nop
/hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h