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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.