name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
ImGui::LogBegin(ImGuiLogType, int) | void ImGui::LogBegin(ImGuiLogType type, int auto_open_depth)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
IM_ASSERT(g.LogEnabled == false);
IM_ASSERT(g.LogFile == NULL);
IM_ASSERT(g.LogBuffer.empty());
g.LogEnabled = true;
g.LogType = type;
g.LogDepthRef = window->DC.TreeDepth;
g.LogDepthToExpand = ((auto_open_depth >= 0) ? auto_open_depth : g.LogDepthToExpandDefault);
g.LogLinePosY = FLT_MAX;
g.LogLineFirstItem = true;
} | pushq %rax
movq 0x5df940(%rip), %rax # 0x7b5230
cmpb $0x0, 0x2f18(%rax)
jne 0x1d5953
cmpq $0x0, 0x2f20(%rax)
jne 0x1d5972
cmpl $0x2, 0x2f28(%rax)
jge 0x1d5991
movq 0x1a28(%rax), %rcx
movb $0x1, 0x2f18(%rax)
movl %edi, 0x2f1c(%rax)
movl 0x118(%rcx), %ecx
movl %ecx, 0x2f40(%rax)
testl %esi, %esi
jns 0x1d593a
movl 0x2f48(%rax), %esi
movl %esi, 0x2f44(%rax)
movl $0x7f7fffff, 0x2f38(%rax) # imm = 0x7F7FFFFF
movb $0x1, 0x2f3c(%rax)
popq %rax
retq
leaq 0x388113(%rip), %rdi # 0x55da6d
leaq 0x386482(%rip), %rsi # 0x55bde3
leaq 0x38811b(%rip), %rcx # 0x55da83
movl $0x23f6, %edx # imm = 0x23F6
callq 0x1a5270
leaq 0x388132(%rip), %rdi # 0x55daab
leaq 0x386463(%rip), %rsi # 0x55bde3
leaq 0x3880fc(%rip), %rcx # 0x55da83
movl $0x23f7, %edx # imm = 0x23F7
callq 0x1a5270
leaq 0x388127(%rip), %rdi # 0x55dabf
leaq 0x386444(%rip), %rsi # 0x55bde3
leaq 0x3880dd(%rip), %rcx # 0x55da83
movl $0x23f8, %edx # imm = 0x23F8
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::CreateNewWindowSettings(char const*) | ImGuiWindowSettings* ImGui::CreateNewWindowSettings(const char* name)
{
ImGuiContext& g = *GImGui;
g.SettingsWindows.push_back(ImGuiWindowSettings());
ImGuiWindowSettings* settings = &g.SettingsWindows.back();
#if !IMGUI_DEBUG_INI_SETTINGS
// Skip to the "###" marker if any. We don't skip past to match the behavior of GetID()
// Preserve the full string when IMGUI_DEBUG_INI_SETTINGS is set to make .ini inspection easier.
if (const char* p = strstr(name, "###"))
name = p;
#endif
settings->Name = ImStrdup(name);
settings->ID = ImHashStr(name);
return settings;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5df511(%rip), %r15 # 0x7b5230
movl 0x2f08(%r15), %eax
cmpl 0x2f0c(%r15), %eax
jne 0x1d5d43
leal 0x1(%rax), %ebp
testl %eax, %eax
je 0x1d5d4f
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x1d5d54
movq 0x2f10(%r15), %r14
jmp 0x1d5dde
movl $0x8, %ecx
cmpl %ebp, %ecx
cmovgl %ecx, %ebp
movslq %ebp, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdi
incl 0x3c0(%r15)
movq 0x5df4ce(%rip), %rsi # 0x7b5240
callq *0x5d6d98(%rip) # 0x7acb10
movq %rax, %r14
movq 0x2f10(%r15), %rsi
testq %rsi, %rsi
je 0x1d5dc9
movslq 0x2f08(%r15), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
callq 0x1a5110
movq 0x2f10(%r15), %rdi
testq %rdi, %rdi
je 0x1d5dbc
movq 0x5df47f(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1d5dbc
decl 0x3c0(%rax)
movq 0x5df47d(%rip), %rsi # 0x7b5240
callq *0x5d6d4f(%rip) # 0x7acb18
movq %r14, 0x2f10(%r15)
movl %ebp, 0x2f0c(%r15)
movl 0x2f08(%r15), %eax
cltq
leaq (%rax,%rax,2), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%r14,%rax,8)
movq $0x0, 0xd(%r14,%rax,8)
movl 0x2f08(%r15), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x2f08(%r15)
testl %ecx, %ecx
js 0x1d5e5e
movq 0x2f10(%r15), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %r14
addq $-0x18, %r14
leaq 0x387d2f(%rip), %rsi # 0x55db55
movq %rbx, %rdi
callq 0x1a57c0
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0x1c09d5
movq %rax, (%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c0da0
movl %eax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x392e6c(%rip), %rdi # 0x568cd1
leaq 0x3886db(%rip), %rsi # 0x55e547
leaq 0x389c14(%rip), %rcx # 0x55fa87
movl $0x4e8, %edx # imm = 0x4E8
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::LoadIniSettingsFromMemory(char const*, unsigned long) | void ImGui::LoadIniSettingsFromMemory(const char* ini_data, size_t ini_size)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.Initialized);
IM_ASSERT(g.SettingsLoaded == false && g.FrameCount == 0);
// For user convenience, we allow passing a non zero-terminated string (hence the ini_size parameter).
// For our convenience and to make the code simpler, we'll also write zero-terminators within the buffer. So let's create a writable copy..
if (ini_size == 0)
ini_size = strlen(ini_data);
char* buf = (char*)IM_ALLOC(ini_size + 1);
char* buf_end = buf + ini_size;
memcpy(buf, ini_data, ini_size);
buf[ini_size] = 0;
void* entry_data = NULL;
ImGuiSettingsHandler* entry_handler = NULL;
char* line_end = NULL;
for (char* line = buf; line < buf_end; line = line_end + 1)
{
// Skip new lines markers, then find end of the line
while (*line == '\n' || *line == '\r')
line++;
line_end = line;
while (line_end < buf_end && *line_end != '\n' && *line_end != '\r')
line_end++;
line_end[0] = 0;
if (line[0] == ';')
continue;
if (line[0] == '[' && line_end > line && line_end[-1] == ']')
{
// Parse "[Type][Name]". Note that 'Name' can itself contains [] characters, which is acceptable with the current format and parsing code.
line_end[-1] = 0;
const char* name_end = line_end - 1;
const char* type_start = line + 1;
char* type_end = (char*)(intptr_t)ImStrchrRange(type_start, name_end, ']');
const char* name_start = type_end ? ImStrchrRange(type_end + 1, name_end, '[') : NULL;
if (!type_end || !name_start)
{
name_start = type_start; // Import legacy entries that have no type
type_start = "Window";
}
else
{
*type_end = 0; // Overwrite first ']'
name_start++; // Skip second '['
}
entry_handler = FindSettingsHandler(type_start);
entry_data = entry_handler ? entry_handler->ReadOpenFn(&g, entry_handler, name_start) : NULL;
}
else if (entry_handler != NULL && entry_data != NULL)
{
// Let type handler parse the line
entry_handler->ReadLineFn(&g, entry_handler, entry_data, line);
}
}
IM_FREE(buf);
g.SettingsLoaded = true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5df307(%rip), %rbx # 0x7b5230
cmpb $0x0, (%rbx)
je 0x1d6110
cmpb $0x0, 0x2edc(%rbx)
jne 0x1d60f1
cmpl $0x0, 0x19c0(%rbx)
jne 0x1d60f1
movq %rsi, %r14
movq %rdi, %r12
testq %rsi, %rsi
jne 0x1d5f62
movq %r12, %rdi
callq 0x1a56a0
movq %rax, %r14
leaq 0x1(%r14), %rdi
incl 0x3c0(%rbx)
movq 0x5df2cd(%rip), %rsi # 0x7b5240
callq *0x5d6b97(%rip) # 0x7acb10
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1a5110
movb $0x0, (%r15,%r14)
testq %r14, %r14
jle 0x1d60b9
addq %r15, %r14
xorl %ebp, %ebp
movq %r15, (%rsp)
xorl %r13d, %r13d
leaq 0x2(%r15), %rax
leaq 0x1(%r15), %rcx
movq %r15, %r12
movzbl (%r12), %edx
cmpl $0xa, %edx
je 0x1d5fbe
cmpl $0xd, %edx
jne 0x1d5fc9
incq %r12
incq %rax
incq %rcx
jmp 0x1d5faf
movq %r12, %r15
cmpq %r14, %r12
jae 0x1d5ff0
cmpb $0xa, %dl
je 0x1d5fea
movzbl %dl, %edx
cmpl $0xd, %edx
je 0x1d5fea
cmpq %r14, %rcx
jae 0x1d5fed
movb (%rcx), %dl
incq %rcx
jmp 0x1d5fd1
decq %rcx
movq %rcx, %r15
movb $0x0, (%r15)
movzbl (%r12), %ecx
cmpl $0x3b, %ecx
je 0x1d6076
cmpl $0x5b, %ecx
jne 0x1d605c
cmpq %r12, %r15
jbe 0x1d605c
cmpb $0x5d, -0x1(%r15)
jne 0x1d605c
movb $0x0, -0x1(%r15)
incq %r12
movq %r15, %rdx
subq %rax, %rdx
movq %r12, %rdi
movl $0x5d, %esi
callq 0x1a5720
testq %rax, %rax
je 0x1d6084
movq %rax, %r13
leaq -0x1(%r15), %rdx
leaq 0x1(%rax), %rdi
subq %rdi, %rdx
movl $0x5b, %esi
callq 0x1a5720
testq %rax, %rax
je 0x1d6084
movb $0x0, (%r13)
incq %rax
movq %r12, %rdi
movq %rax, %r12
jmp 0x1d608b
testq %r13, %r13
je 0x1d6076
testq %rbp, %rbp
je 0x1d6076
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq *0x18(%r13)
incq %r15
cmpq %r14, %r15
jb 0x1d5fa4
jmp 0x1d60b0
leaq 0x397b89(%rip), %rdi # 0x56dc14
callq 0x1d612f
testq %rax, %rax
je 0x1d60a9
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq %rax, %rbp
jmp 0x1d6076
xorl %r13d, %r13d
xorl %ebp, %ebp
jmp 0x1d6076
movq (%rsp), %r15
testq %r15, %r15
je 0x1d60cb
movq 0x5df170(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1d60cb
decl 0x3c0(%rax)
movq 0x5df16e(%rip), %rsi # 0x7b5240
movq %r15, %rdi
callq *0x5d6a3d(%rip) # 0x7acb18
movb $0x1, 0x2edc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x387a9d(%rip), %rdi # 0x55db95
leaq 0x385ce4(%rip), %rsi # 0x55bde3
leaq 0x387a53(%rip), %rcx # 0x55db59
movl $0x24b9, %edx # imm = 0x24B9
callq 0x1a5270
leaq 0x386371(%rip), %rdi # 0x55c488
leaq 0x385cc5(%rip), %rsi # 0x55bde3
leaq 0x387a34(%rip), %rcx # 0x55db59
movl $0x24b8, %edx # imm = 0x24B8
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::SaveIniSettingsToMemory(unsigned long*) | const char* ImGui::SaveIniSettingsToMemory(size_t* out_size)
{
ImGuiContext& g = *GImGui;
g.SettingsDirtyTimer = 0.0f;
g.SettingsIniData.Buf.resize(0);
g.SettingsIniData.Buf.push_back(0);
for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
{
ImGuiSettingsHandler* handler = &g.SettingsHandlers[handler_n];
handler->WriteAllFn(&g, handler, &g.SettingsIniData);
}
if (out_size)
*out_size = (size_t)g.SettingsIniData.size();
return g.SettingsIniData.c_str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x5df0aa(%rip), %rbx # 0x7b5230
movl $0x0, 0x2ee0(%rbx)
leaq 0x2ee8(%rbx), %r15
cmpl $0x0, 0x2eec(%rbx)
js 0x1d61b7
movl $0x0, (%r15)
je 0x1d6227
movq 0x2ef0(%rbx), %r12
xorl %eax, %eax
jmp 0x1d62ac
incl 0x3c0(%rbx)
movq 0x5df07c(%rip), %rsi # 0x7b5240
xorl %edi, %edi
callq *0x5d6944(%rip) # 0x7acb10
movq %rax, %r12
movq 0x2ef0(%rbx), %rsi
testq %rsi, %rsi
je 0x1d6215
movslq 0x2ee8(%rbx), %rdx
movq %r12, %rdi
callq 0x1a5110
movq 0x2ef0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d6208
movq 0x5df033(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1d6208
decl 0x3c0(%rax)
movq 0x5df031(%rip), %rsi # 0x7b5240
callq *0x5d6903(%rip) # 0x7acb18
movq %r12, 0x2ef0(%rbx)
movq $0x0, 0x2ee8(%rbx)
movq 0x5df002(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1d6239
incl 0x3c0(%rax)
movq 0x5df000(%rip), %rsi # 0x7b5240
movl $0x8, %edi
callq *0x5d68c5(%rip) # 0x7acb10
movq %rax, %r12
movq 0x2ef0(%rbx), %rsi
testq %rsi, %rsi
je 0x1d6294
movslq 0x2ee8(%rbx), %rdx
movq %r12, %rdi
callq 0x1a5110
movq 0x2ef0(%rbx), %rdi
testq %rdi, %rdi
je 0x1d6287
movq 0x5defb4(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1d6287
decl 0x3c0(%rax)
movq 0x5defb2(%rip), %rsi # 0x7b5240
callq *0x5d6884(%rip) # 0x7acb18
movq %r12, 0x2ef0(%rbx)
movl $0x8, 0x2eec(%rbx)
movslq 0x2ee8(%rbx), %rax
movb $0x0, (%r12,%rax)
incl 0x2ee8(%rbx)
cmpl $0x0, 0x2ef8(%rbx)
jle 0x1d62ef
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x2f00(%rbx), %rax
leaq (%rax,%r12), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x20(%rax,%r12)
incq %r13
movslq 0x2ef8(%rbx), %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x1d62c6
testq %r14, %r14
je 0x1d6304
movl (%r15), %eax
xorl %ecx, %ecx
subl $0x1, %eax
cmovbl %ecx, %eax
cltq
movq %rax, (%r14)
movq 0x2ef0(%rbx), %rcx
testq %rcx, %rcx
leaq 0x5def23(%rip), %rax # 0x7b5238
cmovneq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::ShowMetricsWindow(bool*)::Funcs::NodeWindows(ImVector<ImGuiWindow*>&, char const*) | static void NodeWindows(ImVector<ImGuiWindow*>& windows, const char* label)
{
if (!ImGui::TreeNode(label, "%s (%d)", label, windows.Size))
return;
for (int i = 0; i < windows.Size; i++)
Funcs::NodeWindow(windows[i], "Window");
ImGui::TreePop();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movl (%rdi), %ecx
leaq 0x388184(%rip), %rsi # 0x55eeec
movq %rdx, %rdi
xorl %eax, %eax
callq 0x1eae0a
testb %al, %al
je 0x1d6daa
cmpl $0x0, (%rbx)
jle 0x1d6da0
xorl %r15d, %r15d
leaq 0x396e8f(%rip), %r14 # 0x56dc14
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq 0x1d7cec
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x1d6d85
popq %rbx
popq %r14
popq %r15
jmp 0x1ebbc9
popq %rbx
popq %r14
popq %r15
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImFontGlyphRangesBuilder::AddText(char const*, char const*) | void ImFontGlyphRangesBuilder::AddText(const char* text, const char* text_end)
{
while (text_end ? (text < text_end) : *text)
{
unsigned int c = 0;
int c_len = ImTextCharFromUtf8(&c, text, text_end);
text += c_len;
if (c_len == 0)
break;
if (c < 0x10000)
AddChar((ImWchar)c);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
testq %rbx, %rbx
je 0x203b61
xorl %eax, %eax
cmpq %rbx, %r14
setb %al
jmp 0x203b65
movsbl (%r14), %eax
testl %eax, %eax
je 0x203baf
movl $0x0, 0x4(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1c02a1
testl %eax, %eax
je 0x203baf
movl 0x4(%rsp), %ecx
cmpq $0xffff, %rcx # imm = 0xFFFF
ja 0x203ba8
movl %ecx, %edx
shrl $0x5, %edx
cmpl %edx, (%r15)
jle 0x203bbb
movl $0x1, %esi
shll %cl, %esi
movq 0x8(%r15), %rcx
orl %esi, (%rcx,%rdx,4)
cltq
addq %rax, %r14
jmp 0x203b52
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x35a97c(%rip), %rdi # 0x55e53e
leaq 0x35a97e(%rip), %rsi # 0x55e547
leaq 0x365db2(%rip), %rcx # 0x569982
movl $0x4de, %edx # imm = 0x4DE
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui_draw.cpp |
ShaderUtilities::attach_point_light(unsigned int, PointLight const&) | void ShaderUtilities::attach_point_light(
const GLuint p_shader_id,
const PointLight &point_light) noexcept
{
setVec3(
p_shader_id,
"point_light.position",
point_light.m_position);
setVec3(
p_shader_id,
"point_light.ambient",
LightingDbWindow::enable_point_light ? point_light.m_phong.m_ambient
: glm::vec3(0.0f));
setVec3(
p_shader_id,
"point_light.diffuse",
LightingDbWindow::enable_point_light ? point_light.m_phong.m_diffuse
: glm::vec3(0.0f));
setVec3(
p_shader_id,
"point_light.specular",
LightingDbWindow::enable_point_light ? point_light.m_phong.m_specular
: glm::vec3(0.0f));
setFloat(
p_shader_id,
"point_light.attenuation_value",
point_light.m_intensity.m_attval);
setFloat(
p_shader_id,
"point_light.constant",
point_light.m_intensity.m_constant);
setFloat(
p_shader_id,
"point_light.linear",
point_light.m_intensity.m_linear);
setFloat(
p_shader_id,
"point_light.quadratic",
point_light.m_intensity.m_quadratic);
ShaderUtilities::setInt(
p_shader_id,
"depth_map",
4);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_CUBE_MAP, point_light.m_buffer.m_cube_map);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x362107(%rip), %rsi # 0x56aaa0
leaq 0x362114(%rip), %rdx # 0x56aab4
leaq 0x18(%rsp), %rdi
callq 0x209290
leaq 0x5a7dbf(%rip), %r12 # 0x7b0770
movq (%r12), %r13
leaq 0x5a7554(%rip), %rax # 0x7aff10
movq 0x18(%rsp), %rsi
movl %ebp, %edi
callq *(%rax)
movl %eax, %edi
movl $0x1, %esi
movq %rbx, %rdx
callq *%r13
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x2089e9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x3620bd(%rip), %rsi # 0x56aab5
leaq 0x3620c9(%rip), %rdx # 0x56aac8
callq 0x209290
leaq 0x5a420c(%rip), %r13 # 0x7acc17
cmpb $0x1, (%r13)
jne 0x208a24
movl 0x24(%rbx), %eax
movl %eax, 0x10(%rsp)
movq 0x1c(%rbx), %rax
movq %rax, 0x8(%rsp)
jmp 0x208a35
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq (%r12), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a74c9(%rip), %rax # 0x7aff10
callq *(%rax)
leaq 0x8(%rsp), %rdx
movl %eax, %edi
movl $0x1, %esi
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208a6f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x36204b(%rip), %rsi # 0x56aac9
leaq 0x362057(%rip), %rdx # 0x56aadc
callq 0x209290
cmpb $0x1, (%r13)
jne 0x208aa3
movl 0x30(%rbx), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rbx), %rax
movq %rax, 0x8(%rsp)
jmp 0x208ab4
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq (%r12), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a744a(%rip), %rax # 0x7aff10
callq *(%rax)
leaq 0x8(%rsp), %rdx
movl %eax, %edi
movl $0x1, %esi
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208aee
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x361fe0(%rip), %rsi # 0x56aadd
leaq 0x361fed(%rip), %rdx # 0x56aaf1
callq 0x209290
cmpb $0x1, (%r13)
jne 0x208b22
movl 0x3c(%rbx), %eax
movl %eax, 0x10(%rsp)
movq 0x34(%rbx), %rax
movq %rax, 0x8(%rsp)
jmp 0x208b33
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq (%r12), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a73cb(%rip), %rax # 0x7aff10
callq *(%rax)
leaq 0x8(%rsp), %rdx
movl %eax, %edi
movl $0x1, %esi
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208b6d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x361f76(%rip), %rsi # 0x56aaf2
leaq 0x361f8c(%rip), %rdx # 0x56ab0f
callq 0x209290
movss 0xc(%rbx), %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0x5a7b4e(%rip), %r12 # 0x7b06e8
movq (%r12), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a7364(%rip), %rax # 0x7aff10
callq *(%rax)
movl %eax, %edi
movss 0x4(%rsp), %xmm0
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208bd0
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x361f31(%rip), %rsi # 0x56ab10
leaq 0x361f3e(%rip), %rdx # 0x56ab24
callq 0x209290
movss 0x10(%rbx), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r12), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a7308(%rip), %rax # 0x7aff10
callq *(%rax)
movl %eax, %edi
movss 0x4(%rsp), %xmm0
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208c2c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x361eea(%rip), %rsi # 0x56ab25
leaq 0x361ef5(%rip), %rdx # 0x56ab37
callq 0x209290
movss 0x14(%rbx), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r12), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a72ac(%rip), %rax # 0x7aff10
callq *(%rax)
movl %eax, %edi
movss 0x4(%rsp), %xmm0
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208c88
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x361ea1(%rip), %rsi # 0x56ab38
leaq 0x361eaf(%rip), %rdx # 0x56ab4d
callq 0x209290
movss 0x18(%rbx), %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r12), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a7250(%rip), %rax # 0x7aff10
callq *(%rax)
movl %eax, %edi
movss 0x4(%rsp), %xmm0
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208ce4
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x18(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x361e5b(%rip), %rsi # 0x56ab4e
leaq 0x361e5d(%rip), %rdx # 0x56ab57
callq 0x209290
leaq 0x5a79f2(%rip), %rax # 0x7b06f8
movq (%rax), %r15
movq 0x18(%rsp), %rsi
movl %ebp, %edi
leaq 0x5a71f9(%rip), %rax # 0x7aff10
callq *(%rax)
movl %eax, %edi
movl $0x4, %esi
callq *%r15
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x208d3a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x5a68b7(%rip), %rax # 0x7af5f8
movl $0x84c4, %edi # imm = 0x84C4
callq *(%rax)
leaq 0x5a6951(%rip), %rax # 0x7af6a0
movl 0x48(%rbx), %esi
movl $0x8513, %edi # imm = 0x8513
callq *(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x208d7a
jmp 0x208d7a
jmp 0x208d7a
jmp 0x208d7a
jmp 0x208d7a
jmp 0x208d7a
jmp 0x208d7a
jmp 0x208d7a
jmp 0x208d7a
movq %rax, %rdi
callq 0x1d8731
| /hbina[P]fatuous/src/misc/shader_utilities.cpp |
AkarinTimer::get_delta_time() | float AkarinTimer::get_delta_time() noexcept
{
static auto start_time = std::chrono::high_resolution_clock::now();
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<float> elapsed_seconds = end - start_time;
start_time = end;
return elapsed_seconds.count();
} | pushq %rax
movb 0x5b0511(%rip), %al # 0x7b99c8
testb %al, %al
je 0x2094e0
callq 0x1a5cd0
movq %rax, %rcx
subq 0x5b04f6(%rip), %rcx # 0x7b99c0
cvtsi2ss %rcx, %xmm0
divss 0x361775(%rip), %xmm0 # 0x56ac4c
movq %rax, 0x5b04e2(%rip) # 0x7b99c0
popq %rax
retq
callq 0x1a66eb
jmp 0x2094bb
nop
| /hbina[P]fatuous/src/misc/akarin_timer.cpp |
stbi__pnm_load(stbi__context*, int*, int*, int*, int, stbi__result_info*) | static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
stbi_uc *out;
STBI_NOTUSED(ri);
if (!stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n))
return 0;
*x = s->img_x;
*y = s->img_y;
if (comp) *comp = s->img_n;
if (!stbi__mad3sizes_valid(s->img_n, s->img_x, s->img_y, 0))
return stbi__errpuc("too large", "PNM too large");
out = (stbi_uc *) stbi__malloc_mad3(s->img_n, s->img_x, s->img_y, 0);
if (!out) return stbi__errpuc("outofmem", "Out of memory");
stbi__getn(s, out, s->img_n * s->img_x * s->img_y);
if (req_comp && req_comp != s->img_n) {
out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y);
if (out == NULL) return out; // stbi__convert_format frees input on failure
}
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, 0x4(%rsp)
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x4(%rdi), %r12
leaq 0x8(%rdi), %r15
movq %rdi, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x21d002
testl %eax, %eax
je 0x214785
movl (%r14), %eax
movl %eax, (%rbp)
movl 0x4(%r14), %ebp
movl %ebp, (%r13)
movl 0x8(%r14), %r13d
testq %rbx, %rbx
je 0x214703
movl %r13d, (%rbx)
movl (%r12), %ebp
movl (%r14), %ebx
movl %r13d, %edi
movl %ebx, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x217dec
testl %eax, %eax
je 0x21476e
movl %r13d, %edi
movl %ebx, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x217f00
testq %rax, %rax
je 0x214777
movq %rax, %r12
imull %r13d, %ebx
imull %ebp, %ebx
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x21a620
movl 0x4(%rsp), %edx
testl %edx, %edx
je 0x214788
movl (%r15), %esi
cmpl %edx, %esi
je 0x214788
movl (%r14), %ecx
movl 0x4(%r14), %r8d
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x219d8b
leaq 0x383538(%rip), %rax # 0x597cad
jmp 0x21477e
leaq 0x35768b(%rip), %rax # 0x56be09
movq %rax, 0x5a5383(%rip) # 0x7b9b08
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/stb/stb_image.h |
stbi__gif_parse_colortable(stbi__context*, unsigned char (*) [4], int, int) | static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
{
int i;
for (i=0; i < num_entries; ++i) {
pal[i][2] = stbi__get8(s);
pal[i][1] = stbi__get8(s);
pal[i][0] = stbi__get8(s);
pal[i][3] = transp == i ? 0 : 255;
}
} | testl %edx, %edx
jle 0x21cd35
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
leaq 0x39(%rdi), %r12
movl %ecx, %eax
movq %rax, (%rsp)
movl %edx, %ebp
xorl %r13d, %r13d
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
jae 0x21cbe6
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movb (%rax), %al
jmp 0x21cc2f
cmpl $0x0, 0x30(%r14)
je 0x21cc0b
movq 0x28(%r14), %rdi
movl 0x34(%r14), %edx
movq %r15, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0x21cc0f
movslq %eax, %rcx
addq %r15, %rcx
movb (%r15), %al
jmp 0x21cc21
xorl %eax, %eax
jmp 0x21cc2f
movl $0x0, 0x30(%r14)
movb $0x0, 0x38(%r14)
xorl %eax, %eax
movq %r12, %rcx
movq %rcx, 0xc0(%r14)
movq %r12, 0xb8(%r14)
movb %al, 0x2(%rbx,%r13,4)
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
jae 0x21cc53
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movb (%rax), %al
jmp 0x21cc9c
cmpl $0x0, 0x30(%r14)
je 0x21cc78
movq 0x28(%r14), %rdi
movl 0x34(%r14), %edx
movq %r15, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0x21cc7c
movslq %eax, %rcx
addq %r15, %rcx
movb (%r15), %al
jmp 0x21cc8e
xorl %eax, %eax
jmp 0x21cc9c
movl $0x0, 0x30(%r14)
movb $0x0, 0x38(%r14)
xorl %eax, %eax
movq %r12, %rcx
movq %rcx, 0xc0(%r14)
movq %r12, 0xb8(%r14)
movb %al, 0x1(%rbx,%r13,4)
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
jae 0x21ccc0
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r14)
movb (%rax), %al
jmp 0x21cd09
cmpl $0x0, 0x30(%r14)
je 0x21cce5
movq 0x28(%r14), %rdi
movl 0x34(%r14), %edx
movq %r15, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0x21cce9
movslq %eax, %rcx
addq %r15, %rcx
movb (%r15), %al
jmp 0x21ccfb
xorl %eax, %eax
jmp 0x21cd09
movl $0x0, 0x30(%r14)
movb $0x0, 0x38(%r14)
xorl %eax, %eax
movq %r12, %rcx
movq %rcx, 0xc0(%r14)
movq %r12, 0xb8(%r14)
movb %al, (%rbx,%r13,4)
cmpq %r13, (%rsp)
setne %al
negb %al
movb %al, 0x3(%rbx,%r13,4)
incq %r13
cmpq %r13, %rbp
jne 0x21cbc7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/stb/stb_image.h |
add_shader_program(unsigned int, std::vector<unsigned int, std::allocator<unsigned int>> const&) | void add_shader_program(
const GLuint p_id,
const std::vector<GLuint> &p_shaders) noexcept
{
ShaderDb::program_map.emplace(
std::make_pair(
p_id,
ShaderProgram(p_shaders)));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0x220060
leaq 0x18(%rsp), %rsi
movl %ebx, (%rsi)
movaps (%r14), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x10(%r14), %rax
movq %rax, 0x18(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x5994d7(%rip), %rdi # 0x7b9be0
callq 0x220b9e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x220725
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x22073b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x1d8731
| /hbina[P]fatuous/src/akarin_database/shader/shader_database.cpp |
entt::basic_registry<entt::entity>::pool_handler<Transform>::pool_handler(entt::basic_registry<entt::entity>::pool_handler<Transform> const&) | pool_handler() ENTT_NOEXCEPT = default; | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x223956
leaq 0x4b8752(%rip), %rax # 0x6dd168
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
leaq 0x38(%r14), %rsi
callq 0x224ace
leaq 0x4b86cb(%rip), %rax # 0x6dd0f8
movq %rax, (%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x50(%rbx)
leaq 0x58(%rbx), %r15
leaq 0x58(%r14), %rsi
movq %r15, %rdi
callq 0x224b86
leaq 0x70(%rbx), %r12
leaq 0x70(%r14), %rsi
movq %r12, %rdi
callq 0x224b86
movl $0x88, %eax
leaq (%rbx,%rax), %rdi
addq %rax, %r14
movq %r14, %rsi
callq 0x223ee2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x224a98
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
jmp 0x224a98
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x224ab1
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
jmp 0x224ab1
movq %rax, %r14
movq %rbx, %rdi
callq 0x2248cc
jmp 0x224ac6
movq %rax, %r14
movq %rbx, %rdi
callq 0x223444
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/entt/single_include/entt/entt.hpp |
RenderingProcess::render(entt::basic_registry<entt::entity>&) | void RenderingProcess::render(
entt::registry &p_reg) noexcept
{
OpenGLSettings::update();
prepare_shadow(p_reg);
render_normal(p_reg);
SkyboxSystem::render(p_reg);
AkarinImgui::render(p_reg);
AkarinGLFW::swap_buffers();
} | pushq %rbx
movq %rdi, %rbx
callq 0x209814
movq %rbx, %rdi
callq 0x2251bb
movq %rbx, %rdi
callq 0x226ac6
movq %rbx, %rdi
callq 0x209a94
movq %rbx, %rdi
callq 0x227d5c
popq %rbx
jmp 0x22228a
| /hbina[P]fatuous/src/processes/rendering_process.cpp |
entt::sigh<void (entt::entity, entt::basic_registry<entt::entity>&, Swarm&)>::publish(entt::entity, entt::basic_registry<entt::entity>&, Swarm&) const | constexpr bool operator==(const basic_hashed_string &other) const ENTT_NOEXCEPT {
return hash == other.hash;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r12
subq (%rdi), %r12
je 0x227b90
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %r12, %r13
sarq $0x4, %r13
addq $-0x10, %r12
movq (%r15), %rdi
addq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x227ba0
addq $-0x10, %r12
decq %r13
jne 0x227b74
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /hbina[P]fatuous/thirdparty/entt/single_include/entt/entt.hpp |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->share)
{
if (ctxconfig->client == GLFW_NO_API ||
ctxconfig->share->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return GLFW_FALSE;
}
}
if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
ctxconfig->source != GLFW_EGL_CONTEXT_API &&
ctxconfig->source != GLFW_OSMESA_CONTEXT_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context creation API 0x%08X",
ctxconfig->source);
return GLFW_FALSE;
}
if (ctxconfig->client != GLFW_NO_API &&
ctxconfig->client != GLFW_OPENGL_API &&
ctxconfig->client != GLFW_OPENGL_ES_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid client API 0x%08X",
ctxconfig->client);
return GLFW_FALSE;
}
if (ctxconfig->client == GLFW_OPENGL_API)
{
if ((ctxconfig->major < 1 || ctxconfig->minor < 0) ||
(ctxconfig->major == 1 && ctxconfig->minor > 5) ||
(ctxconfig->major == 2 && ctxconfig->minor > 1) ||
(ctxconfig->major == 3 && ctxconfig->minor > 3))
{
// OpenGL 1.0 is the smallest valid version
// OpenGL 1.x series ended with version 1.5
// OpenGL 2.x series ended with version 2.1
// OpenGL 3.x series ended with version 3.3
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
if (ctxconfig->profile)
{
if (ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE &&
ctxconfig->profile != GLFW_OPENGL_COMPAT_PROFILE)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid OpenGL profile 0x%08X",
ctxconfig->profile);
return GLFW_FALSE;
}
if (ctxconfig->major <= 2 ||
(ctxconfig->major == 3 && ctxconfig->minor < 2))
{
// Desktop OpenGL context profiles are only defined for version 3.2
// and above
_glfwInputError(GLFW_INVALID_VALUE,
"Context profiles are only defined for OpenGL version 3.2 and above");
return GLFW_FALSE;
}
}
if (ctxconfig->forward && ctxconfig->major <= 2)
{
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above
_glfwInputError(GLFW_INVALID_VALUE,
"Forward-compatibility is only defined for OpenGL version 3.0 and above");
return GLFW_FALSE;
}
}
else if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (ctxconfig->major < 1 || ctxconfig->minor < 0 ||
(ctxconfig->major == 1 && ctxconfig->minor > 1) ||
(ctxconfig->major == 2 && ctxconfig->minor > 0))
{
// OpenGL ES 1.0 is the smallest valid version
// OpenGL ES 1.x series ended with version 1.1
// OpenGL ES 2.x series ended with version 2.0
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL ES version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
}
if (ctxconfig->robustness)
{
if (ctxconfig->robustness != GLFW_NO_RESET_NOTIFICATION &&
ctxconfig->robustness != GLFW_LOSE_CONTEXT_ON_RESET)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context robustness mode 0x%08X",
ctxconfig->robustness);
return GLFW_FALSE;
}
}
if (ctxconfig->release)
{
if (ctxconfig->release != GLFW_RELEASE_BEHAVIOR_NONE &&
ctxconfig->release != GLFW_RELEASE_BEHAVIOR_FLUSH)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context release behavior 0x%08X",
ctxconfig->release);
return GLFW_FALSE;
}
}
return GLFW_TRUE;
} | pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x229294
cmpl $0x0, (%rdi)
je 0x22930a
cmpl $0x0, 0x1f8(%rax)
je 0x22930a
movl 0x4(%rdi), %edx
leal -0x36001(%rdx), %eax
cmpl $0x3, %eax
jae 0x22931f
movl (%rdi), %edx
testl %edx, %edx
je 0x2293f9
cmpl $0x30001, %edx # imm = 0x30001
je 0x229339
cmpl $0x30002, %edx # imm = 0x30002
jne 0x22937b
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
testl %edx, %edx
setle %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
jne 0x229301
cmpl $0x1, %edx
sete %al
cmpl $0x2, %ecx
setae %sil
testb %sil, %al
jne 0x229301
cmpl $0x2, %edx
setne %al
testl %ecx, %ecx
sete %sil
orb %al, %sil
jne 0x2293f9
leaq 0x344c16(%rip), %rsi # 0x56df1e
jmp 0x229368
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x229dd1
jmp 0x229422
leaq 0x344af5(%rip), %rsi # 0x56de1b
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x229dd1
jmp 0x229422
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
testl %edx, %edx
setle %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
jne 0x229361
cmpl $0x1, %edx
sete %al
cmpl $0x6, %ecx
setae %sil
testb %sil, %al
je 0x22938b
leaq 0x344af1(%rip), %rsi # 0x56de59
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
xorl %eax, %eax
callq 0x229dd1
jmp 0x229422
leaq 0x344abd(%rip), %rsi # 0x56de3f
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
jmp 0x22932d
cmpl $0x3, %edx
je 0x22939e
cmpl $0x2, %edx
jne 0x22939a
cmpl $0x1, %ecx
ja 0x229361
xorl %esi, %esi
jmp 0x2293a6
movb $0x1, %sil
cmpl $0x4, %ecx
jae 0x229361
movl 0x1c(%rdi), %eax
leal -0x32001(%rax), %r8d
cmpl $0x2, %r8d
jae 0x2293d7
cmpl $0x3, %edx
setae %al
cmpl $0x2, %ecx
setae %cl
xorb $0x1, %sil
orb %cl, %sil
testb %sil, %al
jne 0x2293f9
leaq 0x344abf(%rip), %rsi # 0x56de94
jmp 0x2293ed
testl %eax, %eax
jne 0x22943e
cmpl $0x2, %edx
ja 0x2293f9
cmpl $0x0, 0x10(%rdi)
je 0x2293f9
leaq 0x344aea(%rip), %rsi # 0x56ded7
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
jmp 0x229313
movl 0x20(%rdi), %edx
leal -0x31001(%rdx), %eax
cmpl $0x2, %eax
jb 0x22940b
testl %edx, %edx
jne 0x229426
movl 0x24(%rdi), %edx
movl $0x1, %ebx
leal -0x35001(%rdx), %eax
cmpl $0x2, %eax
jb 0x229422
testl %edx, %edx
jne 0x229432
movl %ebx, %eax
popq %rbx
retq
leaq 0x344b11(%rip), %rsi # 0x56df3e
jmp 0x229326
leaq 0x344b2c(%rip), %rsi # 0x56df65
jmp 0x229326
leaq 0x344a31(%rip), %rsi # 0x56de76
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %eax, %edx
jmp 0x22932d
| /hbina[P]fatuous/thirdparty/glfw/src/context.c |
glfwInputError | void _glfwInputError(int code, const char* format, ...)
{
_GLFWerror* error;
char description[_GLFW_MESSAGE_SIZE];
if (format)
{
va_list vl;
va_start(vl, format);
vsnprintf(description, sizeof(description), format, vl);
va_end(vl);
description[sizeof(description) - 1] = '\0';
}
else
{
if (code == GLFW_NOT_INITIALIZED)
strcpy(description, "The GLFW library is not initialized");
else if (code == GLFW_NO_CURRENT_CONTEXT)
strcpy(description, "There is no current context");
else if (code == GLFW_INVALID_ENUM)
strcpy(description, "Invalid argument for enum parameter");
else if (code == GLFW_INVALID_VALUE)
strcpy(description, "Invalid value for parameter");
else if (code == GLFW_OUT_OF_MEMORY)
strcpy(description, "Out of memory");
else if (code == GLFW_API_UNAVAILABLE)
strcpy(description, "The requested API is unavailable");
else if (code == GLFW_VERSION_UNAVAILABLE)
strcpy(description, "The requested API version is unavailable");
else if (code == GLFW_PLATFORM_ERROR)
strcpy(description, "A platform-specific error occurred");
else if (code == GLFW_FORMAT_UNAVAILABLE)
strcpy(description, "The requested format is unavailable");
else if (code == GLFW_NO_WINDOW_CONTEXT)
strcpy(description, "The specified window has no context");
else
strcpy(description, "ERROR: UNKNOWN GLFW ERROR");
}
if (_glfw.initialized)
{
error = _glfwPlatformGetTls(&_glfw.errorSlot);
if (!error)
{
error = calloc(1, sizeof(_GLFWerror));
_glfwPlatformSetTls(&_glfw.errorSlot, error);
_glfwPlatformLockMutex(&_glfw.errorLock);
error->next = _glfw.errorListHead;
_glfw.errorListHead = error;
_glfwPlatformUnlockMutex(&_glfw.errorLock);
}
}
else
error = &_glfwMainThreadError;
error->code = code;
strcpy(error->description, description);
if (_glfwErrorCallback)
_glfwErrorCallback(code, description);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movl %edi, %ebx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x229e30
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x229eff
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x500(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
movq %r10, %rdx
callq 0x1a5c30
movb $0x0, 0x3ff(%r14)
leaq 0x5900c0(%rip), %r12 # 0x7b9f48
cmpl $0x0, (%r12)
je 0x229f4c
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x582101(%rip), %rdi # 0x7abfa0
callq 0x236f4d
movq %rax, %r14
testq %rax, %rax
jne 0x229f53
movl $0x1, %edi
movl $0x410, %esi # imm = 0x410
callq 0x1a5fa0
movq %rax, %r14
leaq 0x1fe14(%r12), %rdi
movq %rax, %rsi
callq 0x236f7a
leaq 0x1fe28(%r12), %r15
movq %r15, %rdi
callq 0x237030
movq 0x3e0(%r12), %rax
movq %rax, (%r14)
movq %r14, 0x3e0(%r12)
movq %r15, %rdi
callq 0x23705e
jmp 0x229f53
leal -0x10001(%rbx), %eax
cmpl $0x9, %eax
ja 0x22a0ca
leaq 0x34448f(%rip), %rcx # 0x56e3a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movups 0x35f649(%rip), %xmm0 # 0x58956e
movaps %xmm0, 0xe0(%rsp)
movups 0x35f62a(%rip), %xmm0 # 0x58955e
movaps %xmm0, 0xd0(%rsp)
movl $0x64657a, 0xf0(%rsp) # imm = 0x64657A
jmp 0x229e81
leaq 0x5b106d(%rip), %r14 # 0x7dafc0
movl %ebx, 0x8(%r14)
addq $0xc, %r14
leaq 0xd0(%rsp), %rsi
movq %r14, %rdi
callq 0x1a56e0
movq 0x5b145e(%rip), %rax # 0x7db3d0
testq %rax, %rax
je 0x229f83
leaq 0xd0(%rsp), %rsi
movl %ebx, %edi
callq *%rax
addq $0x4d8, %rsp # imm = 0x4D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movabsq $0x79726f6d656d20, %rax # imm = 0x79726F6D656D20
movq %rax, 0xd6(%rsp)
movabsq $0x6d20666f2074754f, %rax # imm = 0x6D20666F2074754F
movq %rax, 0xd0(%rsp)
jmp 0x229e81
movups 0x35f6cb(%rip), %xmm0 # 0x58968d
movaps %xmm0, 0xe0(%rsp)
movups 0x35f6ac(%rip), %xmm0 # 0x58967d
movaps %xmm0, 0xd0(%rsp)
movl $0x747865, 0xf0(%rsp) # imm = 0x747865
jmp 0x229e81
movups 0x35f5be(%rip), %xmm0 # 0x5895ae
movaps %xmm0, 0xe0(%rsp)
movups 0x35f59f(%rip), %xmm0 # 0x58959e
movaps %xmm0, 0xd0(%rsp)
movl $0x726574, 0xf0(%rsp) # imm = 0x726574
jmp 0x229e81
movups 0x35f5b0(%rip), %xmm0 # 0x5895ce
movups %xmm0, 0xdc(%rsp)
movups 0x35f595(%rip), %xmm0 # 0x5895c2
jmp 0x22a0e0
movups 0x35f60d(%rip), %xmm0 # 0x589646
movaps %xmm0, 0xe0(%rsp)
movups 0x35f5ee(%rip), %xmm0 # 0x589636
movaps %xmm0, 0xd0(%rsp)
movl $0x646572, 0xef(%rsp) # imm = 0x646572
jmp 0x229e81
movups 0x35f527(%rip), %xmm0 # 0x58958e
movups %xmm0, 0xdc(%rsp)
movups 0x35f50c(%rip), %xmm0 # 0x589582
jmp 0x22a0e0
movups 0x35f57d(%rip), %xmm0 # 0x5895fc
movaps %xmm0, 0xe0(%rsp)
movups 0x35f55e(%rip), %xmm0 # 0x5895ec
movaps %xmm0, 0xd0(%rsp)
movb $0x0, 0xf0(%rsp)
jmp 0x229e81
movups 0x35f57c(%rip), %xmm0 # 0x589626
movups %xmm0, 0xe9(%rsp)
movups 0x35f564(%rip), %xmm0 # 0x58961d
movaps %xmm0, 0xe0(%rsp)
movups 0x35f545(%rip), %xmm0 # 0x58960d
jmp 0x22a0e0
movups 0x35f5da(%rip), %xmm0 # 0x5896ab
movups %xmm0, 0xda(%rsp)
movups 0x35f5c1(%rip), %xmm0 # 0x5896a1
movaps %xmm0, 0xd0(%rsp)
jmp 0x229e81
movups 0x35f575(%rip), %xmm0 # 0x589669
movaps %xmm0, 0xe0(%rsp)
movups 0x35f556(%rip), %xmm0 # 0x589659
movaps %xmm0, 0xd0(%rsp)
movl $0x656c62, 0xf0(%rsp) # imm = 0x656C62
jmp 0x229e81
| /hbina[P]fatuous/thirdparty/glfw/src/init.c |
glfwGetError | GLFWAPI int glfwGetError(const char** description)
{
_GLFWerror* error;
int code = GLFW_NO_ERROR;
if (description)
*description = NULL;
if (_glfw.initialized)
error = _glfwPlatformGetTls(&_glfw.errorSlot);
else
error = &_glfwMainThreadError;
if (error)
{
code = error->code;
error->code = GLFW_NO_ERROR;
if (description && code)
*description = error->description;
}
return code;
} | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x22a3b5
movq $0x0, (%rbx)
leaq 0x58fb8c(%rip), %rax # 0x7b9f48
cmpl $0x0, (%rax)
je 0x22a3db
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x581bd3(%rip), %rdi # 0x7abfa0
callq 0x236f4d
testq %rax, %rax
jne 0x22a3e2
xorl %ecx, %ecx
jmp 0x22a408
leaq 0x5b0bde(%rip), %rax # 0x7dafc0
testq %rbx, %rbx
setne %dl
movl 0x8(%rax), %ecx
movl $0x0, 0x8(%rax)
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x22a408
addq $0xc, %rax
movq %rax, (%rbx)
movl %ecx, %eax
popq %rbx
retq
| /hbina[P]fatuous/thirdparty/glfw/src/init.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
return GLFW_RELEASE;
}
if (window->keys[key] == _GLFW_STICK)
{
// Sticky mode: release key now
window->keys[key] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) window->keys[key];
} | pushq %rbx
testq %rdi, %rdi
je 0x22acaa
leaq 0x58f2fb(%rip), %rax # 0x7b9f48
cmpl $0x0, (%rax)
je 0x22ac78
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0x22ac8a
leaq 0x35ec69(%rip), %rsi # 0x5898d1
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x229dd1
jmp 0x22aca6
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x229dd1
jmp 0x22aca6
movl %edx, %eax
movsbl 0x80(%rdi,%rax), %ebx
cmpl $0x3, %ebx
jne 0x22aca6
movb $0x0, 0x80(%rdi,%rax)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x343476(%rip), %rdi # 0x56e127
leaq 0x35eaf8(%rip), %rsi # 0x5897b0
leaq 0x35ec21(%rip), %rcx # 0x5898e0
movl $0x278, %edx # imm = 0x278
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/glfw/src/input.c |
glfwInitGLX | GLFWbool _glfwInitGLX(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_GLX_LIBRARY)
_GLFW_GLX_LIBRARY,
#elif defined(__CYGWIN__)
"libGL-1.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
};
if (_glfw.glx.handle)
return GLFW_TRUE;
for (i = 0; sonames[i]; i++)
{
_glfw.glx.handle = _glfw_dlopen(sonames[i]);
if (_glfw.glx.handle)
break;
}
if (!_glfw.glx.handle)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: Failed to load GLX");
return GLFW_FALSE;
}
_glfw.glx.GetFBConfigs =
_glfw_dlsym(_glfw.glx.handle, "glXGetFBConfigs");
_glfw.glx.GetFBConfigAttrib =
_glfw_dlsym(_glfw.glx.handle, "glXGetFBConfigAttrib");
_glfw.glx.GetClientString =
_glfw_dlsym(_glfw.glx.handle, "glXGetClientString");
_glfw.glx.QueryExtension =
_glfw_dlsym(_glfw.glx.handle, "glXQueryExtension");
_glfw.glx.QueryVersion =
_glfw_dlsym(_glfw.glx.handle, "glXQueryVersion");
_glfw.glx.DestroyContext =
_glfw_dlsym(_glfw.glx.handle, "glXDestroyContext");
_glfw.glx.MakeCurrent =
_glfw_dlsym(_glfw.glx.handle, "glXMakeCurrent");
_glfw.glx.SwapBuffers =
_glfw_dlsym(_glfw.glx.handle, "glXSwapBuffers");
_glfw.glx.QueryExtensionsString =
_glfw_dlsym(_glfw.glx.handle, "glXQueryExtensionsString");
_glfw.glx.CreateNewContext =
_glfw_dlsym(_glfw.glx.handle, "glXCreateNewContext");
_glfw.glx.CreateWindow =
_glfw_dlsym(_glfw.glx.handle, "glXCreateWindow");
_glfw.glx.DestroyWindow =
_glfw_dlsym(_glfw.glx.handle, "glXDestroyWindow");
_glfw.glx.GetProcAddress =
_glfw_dlsym(_glfw.glx.handle, "glXGetProcAddress");
_glfw.glx.GetProcAddressARB =
_glfw_dlsym(_glfw.glx.handle, "glXGetProcAddressARB");
_glfw.glx.GetVisualFromFBConfig =
_glfw_dlsym(_glfw.glx.handle, "glXGetVisualFromFBConfig");
if (!_glfw.glx.GetFBConfigs ||
!_glfw.glx.GetFBConfigAttrib ||
!_glfw.glx.GetClientString ||
!_glfw.glx.QueryExtension ||
!_glfw.glx.QueryVersion ||
!_glfw.glx.DestroyContext ||
!_glfw.glx.MakeCurrent ||
!_glfw.glx.SwapBuffers ||
!_glfw.glx.QueryExtensionsString ||
!_glfw.glx.CreateNewContext ||
!_glfw.glx.CreateWindow ||
!_glfw.glx.DestroyWindow ||
!_glfw.glx.GetProcAddress ||
!_glfw.glx.GetProcAddressARB ||
!_glfw.glx.GetVisualFromFBConfig)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"GLX: Failed to load required entry points");
return GLFW_FALSE;
}
if (!glXQueryExtension(_glfw.x11.display,
&_glfw.glx.errorBase,
&_glfw.glx.eventBase))
{
_glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX extension not found");
return GLFW_FALSE;
}
if (!glXQueryVersion(_glfw.x11.display, &_glfw.glx.major, &_glfw.glx.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"GLX: Failed to query GLX version");
return GLFW_FALSE;
}
if (_glfw.glx.major == 1 && _glfw.glx.minor < 3)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"GLX: GLX version 1.3 is required");
return GLFW_FALSE;
}
if (extensionSupportedGLX("GLX_EXT_swap_control"))
{
_glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)
getProcAddressGLX("glXSwapIntervalEXT");
if (_glfw.glx.SwapIntervalEXT)
_glfw.glx.EXT_swap_control = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_SGI_swap_control"))
{
_glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)
getProcAddressGLX("glXSwapIntervalSGI");
if (_glfw.glx.SwapIntervalSGI)
_glfw.glx.SGI_swap_control = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_MESA_swap_control"))
{
_glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC)
getProcAddressGLX("glXSwapIntervalMESA");
if (_glfw.glx.SwapIntervalMESA)
_glfw.glx.MESA_swap_control = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_ARB_multisample"))
_glfw.glx.ARB_multisample = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_framebuffer_sRGB"))
_glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE;
if (extensionSupportedGLX("GLX_EXT_framebuffer_sRGB"))
_glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_create_context"))
{
_glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)
getProcAddressGLX("glXCreateContextAttribsARB");
if (_glfw.glx.CreateContextAttribsARB)
_glfw.glx.ARB_create_context = GLFW_TRUE;
}
if (extensionSupportedGLX("GLX_ARB_create_context_robustness"))
_glfw.glx.ARB_create_context_robustness = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_create_context_profile"))
_glfw.glx.ARB_create_context_profile = GLFW_TRUE;
if (extensionSupportedGLX("GLX_EXT_create_context_es2_profile"))
_glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_create_context_no_error"))
_glfw.glx.ARB_create_context_no_error = GLFW_TRUE;
if (extensionSupportedGLX("GLX_ARB_context_flush_control"))
_glfw.glx.ARB_context_flush_control = GLFW_TRUE;
return GLFW_TRUE;
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0x582eb0(%rip), %r14 # 0x7b9f48
movl $0x1, %ebx
cmpq $0x0, 0x20e68(%r14)
jne 0x2373b3
xorl %ebx, %ebx
leaq 0x4a61dc(%rip), %r15 # 0x6dd290
movq (%rbx,%r15), %rdi
movl $0x1, %esi
callq 0x1a5fb0
movq %rax, 0x20e68(%r14)
testq %rax, %rax
jne 0x2370eb
addq $0x8, %rbx
cmpq $0x10, %rbx
jne 0x2370b4
leaq 0x3568f2(%rip), %rsi # 0x58d9d1
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
jmp 0x2373ac
leaq 0x3568f7(%rip), %rsi # 0x58d9e9
movq %rax, %rdi
callq 0x1a52e0
movq %rax, 0x20e70(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568ea(%rip), %rsi # 0x58d9f9
callq 0x1a52e0
movq %rax, 0x20e78(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568e5(%rip), %rsi # 0x58da0e
callq 0x1a52e0
movq %rax, 0x20e80(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568de(%rip), %rsi # 0x58da21
callq 0x1a52e0
movq %rax, 0x20e88(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568d6(%rip), %rsi # 0x58da33
callq 0x1a52e0
movq %rax, 0x20e90(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568cc(%rip), %rsi # 0x58da43
callq 0x1a52e0
movq %rax, 0x20e98(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568c4(%rip), %rsi # 0x58da55
callq 0x1a52e0
movq %rax, 0x20ea0(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568b9(%rip), %rsi # 0x58da64
callq 0x1a52e0
movq %rax, 0x20ea8(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568ae(%rip), %rsi # 0x58da73
callq 0x1a52e0
movq %rax, 0x20eb0(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568ad(%rip), %rsi # 0x58da8c
callq 0x1a52e0
movq %rax, 0x20eb8(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x3568a7(%rip), %rsi # 0x58daa0
callq 0x1a52e0
movq %rax, 0x20ec8(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x35689d(%rip), %rsi # 0x58dab0
callq 0x1a52e0
movq %rax, 0x20ed0(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x356894(%rip), %rsi # 0x58dac1
callq 0x1a52e0
movq %rax, 0x20ed8(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x311ddd(%rip), %rsi # 0x549024
callq 0x1a52e0
movq %rax, 0x20ee0(%r14)
movq 0x20e68(%r14), %rdi
leaq 0x356872(%rip), %rsi # 0x58dad3
callq 0x1a52e0
movq %rax, 0x20ec0(%r14)
movdqu 0x20e70(%r14), %xmm3
movdqu 0x20e80(%r14), %xmm0
movdqu 0x20e90(%r14), %xmm5
movdqu 0x20ea0(%r14), %xmm6
movdqu 0x20eb0(%r14), %xmm1
movdqu 0x20ec8(%r14), %xmm2
cmpq $0x0, 0x20ed8(%r14)
setne %dl
cmpq $0x0, 0x20ee0(%r14)
setne %cl
testq %rax, %rax
setne %al
pxor %xmm4, %xmm4
pcmpeqd %xmm4, %xmm6
pshufd $0xb1, %xmm6, %xmm7 # xmm7 = xmm6[1,0,3,2]
pand %xmm6, %xmm7
pcmpeqd %xmm4, %xmm5
pshufd $0xb1, %xmm5, %xmm6 # xmm6 = xmm5[1,0,3,2]
pand %xmm5, %xmm6
packssdw %xmm7, %xmm6
movdqa %xmm0, %xmm5
pcmpeqd %xmm4, %xmm5
pshufd $0xb1, %xmm5, %xmm7 # xmm7 = xmm5[1,0,3,2]
pand %xmm5, %xmm7
pcmpeqd %xmm4, %xmm3
pshufd $0xb1, %xmm3, %xmm5 # xmm5 = xmm3[1,0,3,2]
pand %xmm3, %xmm5
packssdw %xmm7, %xmm5
packssdw %xmm6, %xmm5
packsswb %xmm5, %xmm5
pmovmskb %xmm5, %esi
pcmpeqd %xmm4, %xmm2
pcmpeqd %xmm4, %xmm1
movdqa %xmm1, %xmm3
shufps $0xdd, %xmm2, %xmm3 # xmm3 = xmm3[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1 # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm3, %xmm1
movmskps %xmm1, %edi
orb %sil, %dil
sete %sil
andb %dl, %cl
andb %sil, %cl
testb %al, %cl
je 0x23739e
movq 0x1fec0(%r14), %rdi
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rax
leaq 0x20e64(%r14), %rsi
leaq 0x20e60(%r14), %rdx
callq *%rax
testl %eax, %eax
je 0x2373bb
movq 0x1fec0(%r14), %rdi
leaq 0x20e58(%r14), %rsi
leaq 0x20e5c(%r14), %rdx
callq *0x20e90(%r14)
testl %eax, %eax
je 0x2373c7
cmpl $0x1, 0x20e58(%r14)
jne 0x2373d3
cmpl $0x2, 0x20e5c(%r14)
jg 0x2373d3
leaq 0x3567bb(%rip), %rsi # 0x58db54
jmp 0x2370df
leaq 0x356747(%rip), %rsi # 0x58daec
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x229dd1
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x356754(%rip), %rsi # 0x58db16
jmp 0x2370df
leaq 0x356765(%rip), %rsi # 0x58db33
jmp 0x2370df
leaq 0x35679b(%rip), %rdi # 0x58db75
callq 0x237585
testl %eax, %eax
je 0x237406
leaq 0x3567a0(%rip), %rdi # 0x58db8a
callq 0x2375c2
movq %rax, 0x20ef0(%r14)
testq %rax, %rax
je 0x237406
movl $0x1, 0x20f0c(%r14)
leaq 0x356790(%rip), %rdi # 0x58db9d
callq 0x237585
testl %eax, %eax
je 0x237439
leaq 0x356795(%rip), %rdi # 0x58dbb2
callq 0x2375c2
movq %rax, 0x20ee8(%r14)
testq %rax, %rax
je 0x237439
movl $0x1, 0x20f08(%r14)
leaq 0x356785(%rip), %rdi # 0x58dbc5
callq 0x237585
testl %eax, %eax
je 0x23746c
leaq 0x35678b(%rip), %rdi # 0x58dbdb
callq 0x2375c2
movq %rax, 0x20ef8(%r14)
testq %rax, %rax
je 0x23746c
movl $0x1, 0x20f10(%r14)
leaq 0x35677c(%rip), %rdi # 0x58dbef
callq 0x237585
testl %eax, %eax
je 0x237487
movl $0x1, 0x20f14(%r14)
leaq 0x356775(%rip), %rdi # 0x58dc03
callq 0x237585
testl %eax, %eax
je 0x2374a2
movl $0x1, 0x20f18(%r14)
leaq 0x356773(%rip), %rdi # 0x58dc1c
callq 0x237585
testl %eax, %eax
je 0x2374bd
movl $0x1, 0x20f1c(%r14)
leaq 0x356771(%rip), %rdi # 0x58dc35
callq 0x237585
testl %eax, %eax
je 0x2374f0
leaq 0x356778(%rip), %rdi # 0x58dc4c
callq 0x2375c2
movq %rax, 0x20f00(%r14)
testq %rax, %rax
je 0x2374f0
movl $0x1, 0x20f20(%r14)
leaq 0x356770(%rip), %rdi # 0x58dc67
callq 0x237585
testl %eax, %eax
je 0x23750b
movl $0x1, 0x20f28(%r14)
leaq 0x356777(%rip), %rdi # 0x58dc89
callq 0x237585
testl %eax, %eax
je 0x237526
movl $0x1, 0x20f24(%r14)
leaq 0x35677b(%rip), %rdi # 0x58dca8
callq 0x237585
testl %eax, %eax
je 0x237541
movl $0x1, 0x20f2c(%r14)
leaq 0x356783(%rip), %rdi # 0x58dccb
callq 0x237585
testl %eax, %eax
je 0x23755c
movl $0x1, 0x20f30(%r14)
leaq 0x356788(%rip), %rdi # 0x58dceb
callq 0x237585
movl $0x1, %ebx
testl %eax, %eax
je 0x2373b3
movl $0x1, 0x20f34(%r14)
jmp 0x2373b3
| /hbina[P]fatuous/thirdparty/glfw/src/glx_context.c |
swapIntervalGLX | static void swapIntervalGLX(int interval)
{
_GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (_glfw.glx.EXT_swap_control)
{
_glfw.glx.SwapIntervalEXT(_glfw.x11.display,
window->context.glx.window,
interval);
}
else if (_glfw.glx.MESA_swap_control)
_glfw.glx.SwapIntervalMESA(interval);
else if (_glfw.glx.SGI_swap_control)
{
if (interval > 0)
_glfw.glx.SwapIntervalSGI(interval);
}
} | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x58207f(%rip), %r14 # 0x7b9f48
leaq 0x1fe1c(%r14), %rdi
callq 0x236f4d
movq %r14, %rdx
cmpl $0x0, 0x20f0c(%r14)
je 0x237f02
movq 0x20ef0(%rdx), %rcx
movq 0x1fec0(%rdx), %rdi
movq 0x278(%rax), %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
cmpl $0x0, 0x20f10(%rdx)
je 0x237f1a
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x20ef8(%rdx)
testl %ebx, %ebx
jle 0x237f36
cmpl $0x0, 0x20f08(%rdx)
je 0x237f36
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x20ee8(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /hbina[P]fatuous/thirdparty/glfw/src/glx_context.c |
glfwTerminateEGL | void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
} | pushq %rbx
leaq 0x581ab7(%rip), %rbx # 0x7b9f48
movq 0x20f88(%rbx), %rdi
testq %rdi, %rdi
je 0x2384ae
callq *0x20fe0(%rbx)
movq $0x0, 0x20f88(%rbx)
movq 0x20fb0(%rbx), %rdi
testq %rdi, %rdi
je 0x2384ca
callq 0x1a6350
movq $0x0, 0x20fb0(%rbx)
popq %rbx
retq
| /hbina[P]fatuous/thirdparty/glfw/src/egl_context.c |
makeContextCurrentEGL | static void makeContextCurrentEGL(_GLFWwindow* window)
{
if (window)
{
if (!eglMakeCurrent(_glfw.egl.display,
window->context.egl.surface,
window->context.egl.surface,
window->context.egl.handle))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to make context current: %s",
getEGLErrorString(eglGetError()));
return;
}
}
else
{
if (!eglMakeCurrent(_glfw.egl.display,
EGL_NO_SURFACE,
EGL_NO_SURFACE,
EGL_NO_CONTEXT))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to clear current context: %s",
getEGLErrorString(eglGetError()));
return;
}
}
_glfwPlatformSetTls(&_glfw.contextSlot, window);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x581219(%rip), %r14 # 0x7b9f48
movq 0x20f88(%r14), %rdi
movq 0x21010(%r14), %rax
testq %rbx, %rbx
je 0x238d70
movq 0x288(%rbx), %rcx
movq 0x290(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x238d7c
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2384cc
leaq 0x35589b(%rip), %rsi # 0x58e609
jmp 0x238dac
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
testl %eax, %eax
je 0x238d97
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x573218(%rip), %rdi # 0x7abfa0
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x236f7a
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2384cc
leaq 0x355885(%rip), %rsi # 0x58e631
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x229dd1
| /hbina[P]fatuous/thirdparty/glfw/src/egl_context.c |
glfwCreateContextOSMesa | GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
OSMesaContext share = NULL;
const int accumBits = fbconfig->accumRedBits +
fbconfig->accumGreenBits +
fbconfig->accumBlueBits +
fbconfig->accumAlphaBits;
if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"OSMesa: OpenGL ES is not available on OSMesa");
return GLFW_FALSE;
}
if (ctxconfig->share)
share = ctxconfig->share->context.osmesa.handle;
if (OSMesaCreateContextAttribs)
{
int index = 0, attribs[40];
setAttrib(OSMESA_FORMAT, OSMESA_RGBA);
setAttrib(OSMESA_DEPTH_BITS, fbconfig->depthBits);
setAttrib(OSMESA_STENCIL_BITS, fbconfig->stencilBits);
setAttrib(OSMESA_ACCUM_BITS, accumBits);
if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
{
setAttrib(OSMESA_PROFILE, OSMESA_CORE_PROFILE);
}
else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
{
setAttrib(OSMESA_PROFILE, OSMESA_COMPAT_PROFILE);
}
if (ctxconfig->major != 1 || ctxconfig->minor != 0)
{
setAttrib(OSMESA_CONTEXT_MAJOR_VERSION, ctxconfig->major);
setAttrib(OSMESA_CONTEXT_MINOR_VERSION, ctxconfig->minor);
}
if (ctxconfig->forward)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"OSMesa: Forward-compatible contexts not supported");
return GLFW_FALSE;
}
setAttrib(0, 0);
window->context.osmesa.handle =
OSMesaCreateContextAttribs(attribs, share);
}
else
{
if (ctxconfig->profile)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"OSMesa: OpenGL profiles unavailable");
return GLFW_FALSE;
}
window->context.osmesa.handle =
OSMesaCreateContextExt(OSMESA_RGBA,
fbconfig->depthBits,
fbconfig->stencilBits,
accumBits,
share);
}
if (window->context.osmesa.handle == NULL)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"OSMesa: Failed to create context");
return GLFW_FALSE;
}
window->context.makeCurrent = makeContextCurrentOSMesa;
window->context.swapBuffers = swapBuffersOSMesa;
window->context.swapInterval = swapIntervalOSMesa;
window->context.extensionSupported = extensionSupportedOSMesa;
window->context.getProcAddress = getProcAddressOSMesa;
window->context.destroy = destroyContextOSMesa;
return GLFW_TRUE;
} | pushq %rbx
subq $0xa0, %rsp
cmpl $0x30002, (%rsi) # imm = 0x30002
jne 0x239264
leaq 0x355589(%rip), %rsi # 0x58e7e1
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
jmp 0x239406
movq %rdi, %rbx
movl 0x1c(%rdx), %ecx
addl 0x18(%rdx), %ecx
addl 0x20(%rdx), %ecx
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x239282
movq 0x2a0(%rax), %r8
jmp 0x239285
xorl %r8d, %r8d
addl 0x24(%rdx), %ecx
leaq 0x580cb9(%rip), %r9 # 0x7b9f48
movq 0x21048(%r9), %rax
testq %rax, %rax
je 0x2392f2
movabsq $0x190800000022, %rdi # imm = 0x190800000022
movq %rdi, (%rsp)
movl $0x30, 0x8(%rsp)
movl 0x10(%rdx), %edi
movl %edi, 0xc(%rsp)
movl $0x31, 0x10(%rsp)
movl 0x14(%rdx), %edx
movl %edx, 0x14(%rsp)
movl $0x32, 0x18(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x1c(%rsi), %edx
cmpl $0x32001, %edx # imm = 0x32001
je 0x239308
movl $0x8, %ecx
cmpl $0x32002, %edx # imm = 0x32002
jne 0x23931e
movl $0x35, %ecx
jmp 0x23930d
cmpl $0x0, 0x1c(%rsi)
je 0x23937f
leaq 0x3555ab(%rip), %rsi # 0x58e8ae
jmp 0x2393ff
movl $0x34, %ecx
movl $0x33, 0x20(%rsp)
movl %ecx, 0x24(%rsp)
movl $0xa, %ecx
movl 0x8(%rsi), %edi
movl 0xc(%rsi), %edx
movl %edi, %r9d
xorl $0x1, %r9d
orl %edx, %r9d
je 0x239359
leal (,%rcx,4), %r9d
movl $0x36, (%rsp,%r9)
movl %ecx, %r10d
movl %edi, 0x4(%rsp,%r10,4)
movl $0x37, 0x8(%rsp,%r9)
orl $0x4, %ecx
movl %edx, 0xc(%rsp,%r9)
cmpl $0x0, 0x10(%rsi)
je 0x23936b
leaq 0x355516(%rip), %rsi # 0x58e87c
jmp 0x2393ff
movl %ecx, %ecx
movq $0x0, (%rsp,%rcx,4)
movq %rsp, %rdi
movq %r8, %rsi
callq *%rax
jmp 0x239391
movl 0x10(%rdx), %esi
movl 0x14(%rdx), %edx
movl $0x1908, %edi # imm = 0x1908
callq *0x21040(%r9)
movq %rax, 0x2a0(%rbx)
testq %rax, %rax
je 0x2393f8
leaq 0x74(%rip), %rax # 0x239418
movq %rax, 0x240(%rbx)
leaq 0x146(%rip), %rax # 0x2394f8
movq %rax, 0x248(%rbx)
leaq 0x139(%rip), %rax # 0x2394f9
movq %rax, 0x250(%rbx)
leaq 0x12c(%rip), %rax # 0x2394fa
movq %rax, 0x258(%rbx)
leaq 0x121(%rip), %rax # 0x2394fd
movq %rax, 0x260(%rbx)
leaq 0x120(%rip), %rax # 0x23950a
movq %rax, 0x268(%rbx)
movl $0x1, %ebx
jmp 0x23940d
leaq 0x3554d3(%rip), %rsi # 0x58e8d2
xorl %ebx, %ebx
movl $0x10007, %edi # imm = 0x10007
xorl %eax, %eax
callq 0x229dd1
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
| /hbina[P]fatuous/thirdparty/glfw/src/osmesa_context.c |
glfwGetOSMesaContext | GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.osmesa.handle;
} | pushq %rbx
leaq 0x58083a(%rip), %rax # 0x7b9f48
cmpl $0x0, (%rax)
je 0x239725
cmpl $0x0, 0x1f8(%rdi)
je 0x23972e
movq 0x2a0(%rdi), %rbx
jmp 0x23973e
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x239735
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x229dd1
movq %rbx, %rax
popq %rbx
retq
nop
| /hbina[P]fatuous/thirdparty/glfw/src/osmesa_context.c |
Assimp::Importer::ApplyCustomizedPostProcessing(Assimp::BaseProcess*, bool) | const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) {
ASSIMP_BEGIN_EXCEPTION_REGION();
// Return immediately if no scene is active
if ( NULL == pimpl->mScene ) {
return NULL;
}
// If no flags are given, return the current scene with no further action
if ( NULL == rootProcess ) {
return pimpl->mScene;
}
// In debug builds: run basic flag validation
ASSIMP_LOG_INFO( "Entering customized post processing pipeline" );
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
// The ValidateDS process plays an exceptional role. It isn't contained in the global
// list of post-processing steps, so we need to call it manually.
if ( requestValidation )
{
ValidateDSProcess ds;
ds.ExecuteOnScene( this );
if ( !pimpl->mScene ) {
return NULL;
}
}
#endif // no validation
#ifdef ASSIMP_BUILD_DEBUG
if ( pimpl->bExtraVerbose )
{
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
ASSIMP_LOG_ERROR( "Verbose Import is not available due to build settings" );
#endif // no validation
}
#else
if ( pimpl->bExtraVerbose ) {
ASSIMP_LOG_WARN( "Not a debug build, ignoring extra verbose setting" );
}
#endif // ! DEBUG
std::unique_ptr<Profiler> profiler( GetPropertyInteger( AI_CONFIG_GLOB_MEASURE_TIME, 0 ) ? new Profiler() : NULL );
if ( profiler ) {
profiler->BeginRegion( "postprocess" );
}
rootProcess->ExecuteOnScene( this );
if ( profiler ) {
profiler->EndRegion( "postprocess" );
}
// If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
if ( pimpl->bExtraVerbose || requestValidation ) {
ASSIMP_LOG_DEBUG( "Verbose Import: revalidating data structures" );
ValidateDSProcess ds;
ds.ExecuteOnScene( this );
if ( !pimpl->mScene ) {
ASSIMP_LOG_ERROR( "Verbose Import: failed to revalidate data structures" );
}
}
// clear any data allocated by post-process steps
pimpl->mPPShared->Clean();
ASSIMP_LOG_INFO( "Leaving customized post processing pipeline" );
ASSIMP_END_EXCEPTION_REGION( const aiScene* );
return pimpl->mScene;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x23c0ce
movq %rsi, %r14
testq %rsi, %rsi
je 0x23c0d0
movl %edx, %ebp
movq %rdi, %rbx
callq 0x241234
leaq 0x353277(%rip), %rsi # 0x58f0fe
movq %rax, %rdi
callq 0x24114a
testb %bpl, %bpl
je 0x23bec5
leaq 0x8(%rsp), %rdi
callq 0x24188c
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x24baae
movq (%rbx), %rax
movq 0x50(%rax), %r15
leaq 0x8(%rsp), %rdi
callq 0x2418aa
testq %r15, %r15
je 0x23c0ce
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
movq (%rbx), %rdi
addq $0x78, %rdi
leaq 0x353029(%rip), %rsi # 0x58ef07
callq 0x23d3f6
cmpl $0x0, (%rax)
je 0x23bf60
movl $0x30, %edi
callq 0x1a5230
movq %rax, %r15
addq $0x8, %rax
movl $0x0, 0x8(%r15)
xorl %ecx, %ecx
movq %rcx, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rcx, 0x28(%r15)
movq %r15, 0x28(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x353144(%rip), %rsi # 0x58f06d
leaq 0x353148(%rip), %rdx # 0x58f078
leaq 0x8(%rsp), %rdi
callq 0x209290
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x23cae2
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x23bf69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x23bf69
movq $0x0, 0x28(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24baae
movq 0x28(%rsp), %r14
testq %r14, %r14
je 0x23bfc3
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3530df(%rip), %rsi # 0x58f06d
leaq 0x3530e3(%rip), %rdx # 0x58f078
leaq 0x8(%rsp), %rdi
callq 0x209290
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23cbf6
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x23bfc3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq (%rbx), %rax
orb 0x138(%rax), %bpl
cmpb $0x1, %bpl
jne 0x23c029
callq 0x241234
leaq 0x35314c(%rip), %rsi # 0x58f12b
movq %rax, %rdi
callq 0x241112
leaq 0x8(%rsp), %rdi
callq 0x24188c
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x24baae
movq (%rbx), %rax
cmpq $0x0, 0x50(%rax)
jne 0x23c01c
callq 0x241234
leaq 0x353144(%rip), %rsi # 0x58f158
movq %rax, %rdi
callq 0x2411ba
leaq 0x8(%rsp), %rdi
callq 0x2418aa
movq (%rbx), %rax
movq 0x140(%rax), %rdi
callq 0x23cd4c
callq 0x241234
leaq 0x35314c(%rip), %rsi # 0x58f18d
movq %rax, %rdi
callq 0x24114a
leaq 0x28(%rsp), %rdi
callq 0x23cd8e
movq (%rbx), %rax
movq 0x50(%rax), %rax
jmp 0x23c0d0
jmp 0x23c0b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2418aa
jmp 0x23c0c1
jmp 0x23c0af
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x23c08d
jmp 0x23c0b7
jmp 0x23c0b4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x23c0b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x23c0b7
jmp 0x23c0b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2418aa
jmp 0x23c0b7
jmp 0x23c0af
movq %rax, %rbx
jmp 0x23c0c1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x23cd8e
movq %rbx, %rdi
callq 0x1a50d0
callq 0x1a5e20
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Common/Importer.cpp |
Assimp::PretransformVertices::SetupProperties(Assimp::Importer const*) | void PretransformVertices::SetupProperties(const Importer* pImp)
{
// Get the current value of AI_CONFIG_PP_PTV_KEEP_HIERARCHY, AI_CONFIG_PP_PTV_NORMALIZE,
// AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION and AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION
configKeepHierarchy = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_KEEP_HIERARCHY,0));
configNormalize = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE,0));
configTransform = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION,0));
configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x33c2bf(%rip), %rsi # 0x594b00
movq %r14, %rdi
xorl %edx, %edx
callq 0x23ba82
testl %eax, %eax
setne 0x18(%rbx)
leaq 0x33c2be(%rip), %rsi # 0x594b16
movq %r14, %rdi
xorl %edx, %edx
callq 0x23ba82
testl %eax, %eax
setne 0x19(%rbx)
leaq 0x33c2b8(%rip), %rsi # 0x594b27
movq %r14, %rdi
xorl %edx, %edx
callq 0x23ba82
testl %eax, %eax
setne 0x1a(%rbx)
movl $0x3f800000, %eax # imm = 0x3F800000
movq %rsp, %rcx
movl %eax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rcx)
movl %eax, 0x14(%rcx)
movups %xmm0, 0x18(%rcx)
movl %eax, 0x28(%rcx)
movups %xmm0, 0x2c(%rcx)
movl %eax, 0x3c(%rcx)
leaq 0x33c29e(%rip), %rdx # 0x594b46
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x23c524
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x30(%r15), %xmm3
movups %xmm3, 0x4c(%rbx)
movups %xmm2, 0x3c(%rbx)
movups %xmm1, 0x2c(%rbx)
movups %xmm0, 0x1c(%rbx)
leaq 0x33c27f(%rip), %rsi # 0x594b61
movq %r14, %rdi
xorl %edx, %edx
callq 0x23ba82
testl %eax, %eax
setne 0x5c(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp |
Assimp::SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode*, std::vector<std::pair<aiMesh*, unsigned int>, std::allocator<std::pair<aiMesh*, unsigned int>>> const&) | void SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode* pcNode,
const std::vector<std::pair<aiMesh*, unsigned int> >& avList) {
// for every index in out list build a new entry
std::vector<unsigned int> aiEntries;
aiEntries.reserve(pcNode->mNumMeshes + 1);
for (unsigned int i = 0; i < pcNode->mNumMeshes;++i) {
for (unsigned int a = 0; a < avList.size();++a) {
if (avList[a].second == pcNode->mMeshes[i]) {
aiEntries.push_back(a);
}
}
}
// now build the new list
delete[] pcNode->mMeshes;
pcNode->mNumMeshes = (unsigned int)aiEntries.size();
pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
for (unsigned int b = 0; b < pcNode->mNumMeshes;++b) {
pcNode->mMeshes[b] = aiEntries[b];
}
// recusively update all other nodes
for (unsigned int i = 0; i < pcNode->mNumChildren;++i) {
UpdateNode ( pcNode->mChildren[i], avList );
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0x460(%r14), %esi
incl %esi
callq 0x2509a4
movl 0x460(%r14), %edx
testl %edx, %edx
je 0x26333c
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movl $0x0, 0xc(%rsp)
cmpq %rax, %rcx
je 0x26332f
xorl %edx, %edx
xorl %edi, %edi
shlq $0x4, %rdx
movl 0x8(%rax,%rdx), %eax
movq 0x468(%r14), %rcx
cmpl (%rcx,%r13,4), %eax
jne 0x263304
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x2632f9
movl %edi, (%rsi)
addq $0x4, 0x18(%rsp)
jmp 0x263304
movq %r15, %rdi
movq %r12, %rdx
callq 0x21f20e
movl 0xc(%rsp), %edx
incl %edx
movl %edx, 0xc(%rsp)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
movl %edx, %edi
cmpq %rdx, %rsi
ja 0x2632ce
movl 0x460(%r14), %edx
jmp 0x263332
movq %rax, %rcx
incq %r13
movl %edx, %esi
cmpq %rsi, %r13
jb 0x2632bd
movq 0x468(%r14), %rdi
testq %rdi, %rdi
je 0x26334d
callq 0x1a5610
movq 0x18(%rsp), %r15
subq 0x10(%rsp), %r15
movabsq $0x3fffffffc, %rdi # imm = 0x3FFFFFFFC
andq %r15, %rdi
shrq $0x2, %r15
movl %r15d, 0x460(%r14)
callq 0x1a57a0
movq %rax, 0x468(%r14)
testl %r15d, %r15d
je 0x2633a3
xorl %eax, %eax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %ecx
movq 0x468(%r14), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
movl 0x460(%r14), %ecx
cmpq %rcx, %rax
jb 0x263382
cmpl $0x0, 0x450(%r14)
je 0x2633d2
xorl %r15d, %r15d
movq 0x458(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x263266
incq %r15
movl 0x450(%r14), %eax
cmpq %rax, %r15
jb 0x2633b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2633e9
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2633fb
jmp 0x2633fb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x263415
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp |
UpdateUVIndex(std::__cxx11::list<Assimp::TTUpdateInfo, std::allocator<Assimp::TTUpdateInfo>> const&, unsigned int) | void UpdateUVIndex(const std::list<TTUpdateInfo>& l, unsigned int n)
{
// Don't set if == 0 && wasn't set before
for (std::list<TTUpdateInfo>::const_iterator it = l.begin();it != l.end(); ++it) {
const TTUpdateInfo& info = *it;
if (info.directShortcut)
*info.directShortcut = n;
else if (!n)
{
info.mat->AddProperty<int>((int*)&n,1,AI_MATKEY_UVWSRC(info.semantic,info.index));
}
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0x14(%rsp)
movq (%rdi), %r12
cmpq %rdi, %r12
je 0x264cab
movq %rdi, %rbx
leaq 0x32bff3(%rip), %r14 # 0x590c54
leaq 0x14(%rsp), %r15
movq 0x10(%r12), %rax
movl 0x14(%rsp), %ecx
testq %rax, %rax
je 0x264c78
movl %ecx, (%rax)
jmp 0x264ca2
testl %ecx, %ecx
jne 0x264ca2
movq 0x18(%r12), %rdi
movl 0x20(%r12), %r8d
movl 0x24(%r12), %r9d
movl $0x4, (%rsp)
movq %r15, %rsi
movl $0x4, %edx
movq %r14, %rcx
callq 0x2468bc
movq (%r12), %r12
cmpq %rbx, %r12
jne 0x264c66
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp |
Assimp::OptimizeMeshesProcess::IsActive(unsigned int) const | bool OptimizeMeshesProcess::IsActive( unsigned int pFlags) const
{
// Our behaviour needs to be different if the SortByPType or SplitLargeMeshes
// steps are active. Thus we need to query their flags here and store the
// information, although we're breaking const-correctness.
// That's a serious design flaw, consider redesign.
if( 0 != (pFlags & aiProcess_OptimizeMeshes) ) {
pts = (0 != (pFlags & aiProcess_SortByPType));
max_verts = ( 0 != ( pFlags & aiProcess_SplitLargeMeshes ) ) ? DeadBeef : max_verts;
return true;
}
return false;
} | movl %esi, %eax
btl $0x15, %esi
jae 0x268c00
movl %eax, %ecx
shrl $0xf, %ecx
andb $0x1, %cl
movb %cl, 0x50(%rdi)
movl $0xdeadbeef, %ecx # imm = 0xDEADBEEF
testb %al, %al
js 0x268bfd
movl 0x54(%rdi), %ecx
movl %ecx, 0x54(%rdi)
shrl $0x15, %eax
andl $0x1, %eax
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp |
Assimp::AMFImporter::~AMFImporter() | AMFImporter::~AMFImporter()
{
if(mReader != nullptr) delete mReader;
// Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
Clear();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x471efb(%rip), %rax # 0x6de538
movq %rax, (%rdi)
movq 0x98(%rdi), %rdi
testq %rdi, %rdi
je 0x26c652
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x26c58c
leaq 0xd8(%rbx), %rdi
callq 0x270b18
leaq 0xc0(%rbx), %rdi
callq 0x270b5e
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x26c690
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
leaq 0x80(%rbx), %r14
movq 0x80(%rbx), %rdi
cmpq %r14, %rdi
je 0x26c6b8
movq (%rdi), %r15
movl $0x18, %esi
callq 0x1a5190
movq %r15, %rdi
cmpq %r14, %r15
jne 0x26c6a3
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x247876
nop
| /hbina[P]fatuous/thirdparty/assimp/code/AMF/AMFImporter.cpp |
Assimp::AMFImporter::Postprocess_BuildScene(aiScene*) | void AMFImporter::Postprocess_BuildScene(aiScene* pScene)
{
std::list<aiNode*> node_list;
std::list<aiMesh*> mesh_list;
std::list<CAMFImporter_NodeElement_Metadata*> meta_list;
//
// Because for AMF "material" is just complex colors mixing so aiMaterial will not be used.
// For building aiScene we are must to do few steps:
// at first creating root node for aiScene.
pScene->mRootNode = new aiNode;
pScene->mRootNode->mParent = nullptr;
pScene->mFlags |= AI_SCENE_FLAGS_ALLOW_SHARED;
// search for root(<amf>) element
CAMFImporter_NodeElement* root_el = nullptr;
for(CAMFImporter_NodeElement* ne: mNodeElement_List)
{
if(ne->Type != CAMFImporter_NodeElement::ENET_Root) continue;
root_el = ne;
break;
}// for(const CAMFImporter_NodeElement* ne: mNodeElement_List)
// Check if root element are found.
if(root_el == nullptr) throw DeadlyImportError("Root(<amf>) element not found.");
// after that walk through children of root and collect data. Five types of nodes can be placed at top level - in <amf>: <object>, <material>, <texture>,
// <constellation> and <metadata>. But at first we must read <material> and <texture> because they will be used in <object>. <metadata> can be read
// at any moment.
//
// 1. <material>
// 2. <texture> will be converted later when processing triangles list. \sa Postprocess_BuildMeshSet
for(const CAMFImporter_NodeElement* root_child: root_el->Child)
{
if(root_child->Type == CAMFImporter_NodeElement::ENET_Material) Postprocess_BuildMaterial(*((CAMFImporter_NodeElement_Material*)root_child));
}
// After "appearance" nodes we must read <object> because it will be used in <constellation> -> <instance>.
//
// 3. <object>
for(const CAMFImporter_NodeElement* root_child: root_el->Child)
{
if(root_child->Type == CAMFImporter_NodeElement::ENET_Object)
{
aiNode* tnode = nullptr;
// for <object> mesh and node must be built: object ID assigned to aiNode name and will be used in future for <instance>
Postprocess_BuildNodeAndObject(*((CAMFImporter_NodeElement_Object*)root_child), mesh_list, &tnode);
if(tnode != nullptr) node_list.push_back(tnode);
}
}// for(const CAMFImporter_NodeElement* root_child: root_el->Child)
// And finally read rest of nodes.
//
for(const CAMFImporter_NodeElement* root_child: root_el->Child)
{
// 4. <constellation>
if(root_child->Type == CAMFImporter_NodeElement::ENET_Constellation)
{
// <object> and <constellation> at top of self abstraction use aiNode. So we can use only aiNode list for creating new aiNode's.
Postprocess_BuildConstellation(*((CAMFImporter_NodeElement_Constellation*)root_child), node_list);
}
// 5, <metadata>
if(root_child->Type == CAMFImporter_NodeElement::ENET_Metadata) meta_list.push_back((CAMFImporter_NodeElement_Metadata*)root_child);
}// for(const CAMFImporter_NodeElement* root_child: root_el->Child)
// at now we can add collected metadata to root node
Postprocess_AddMetadata(meta_list, *pScene->mRootNode);
//
// Check constellation children
//
// As said in specification:
// "When multiple objects and constellations are defined in a single file, only the top level objects and constellations are available for printing."
// What that means? For example: if some object is used in constellation then you must show only constellation but not original object.
// And at this step we are checking that relations.
nl_clean_loop:
if(node_list.size() > 1)
{
// walk through all nodes
for(std::list<aiNode*>::iterator nl_it = node_list.begin(); nl_it != node_list.end(); ++nl_it)
{
// and try to find them in another top nodes.
std::list<aiNode*>::const_iterator next_it = nl_it;
++next_it;
for(; next_it != node_list.end(); ++next_it)
{
if((*next_it)->FindNode((*nl_it)->mName) != nullptr)
{
// if current top node(nl_it) found in another top node then erase it from node_list and restart search loop.
node_list.erase(nl_it);
goto nl_clean_loop;
}
}// for(; next_it != node_list.end(); next_it++)
}// for(std::list<aiNode*>::const_iterator nl_it = node_list.begin(); nl_it != node_list.end(); nl_it++)
}
//
// move created objects to aiScene
//
//
// Nodes
if(!node_list.empty())
{
std::list<aiNode*>::const_iterator nl_it = node_list.begin();
pScene->mRootNode->mNumChildren = static_cast<unsigned int>(node_list.size());
pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
for(size_t i = 0; i < pScene->mRootNode->mNumChildren; i++)
{
// Objects and constellation that must be showed placed at top of hierarchy in <amf> node. So all aiNode's in node_list must have
// mRootNode only as parent.
(*nl_it)->mParent = pScene->mRootNode;
pScene->mRootNode->mChildren[i] = *nl_it++;
}
}// if(node_list.size() > 0)
//
// Meshes
if(!mesh_list.empty())
{
std::list<aiMesh*>::const_iterator ml_it = mesh_list.begin();
pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
for(size_t i = 0; i < pScene->mNumMeshes; i++) pScene->mMeshes[i] = *ml_it++;
}// if(mesh_list.size() > 0)
//
// Textures
pScene->mNumTextures = static_cast<unsigned int>(mTexture_Converted.size());
if(pScene->mNumTextures > 0)
{
size_t idx;
idx = 0;
pScene->mTextures = new aiTexture*[pScene->mNumTextures];
for(const SPP_Texture& tex_convd: mTexture_Converted)
{
pScene->mTextures[idx] = new aiTexture;
pScene->mTextures[idx]->mWidth = static_cast<unsigned int>(tex_convd.Width);
pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
pScene->mTextures[idx]->pcData = (aiTexel*)tex_convd.Data;
// texture format description.
strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
idx++;
}// for(const SPP_Texture& tex_convd: mTexture_Converted)
// Create materials for embedded textures.
idx = 0;
pScene->mNumMaterials = static_cast<unsigned int>(mTexture_Converted.size());
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
for(const SPP_Texture& tex_convd: mTexture_Converted)
{
const aiString texture_id(AI_EMBEDDED_TEXNAME_PREFIX + to_string(idx));
const int mode = aiTextureOp_Multiply;
const int repeat = tex_convd.Tiled ? 1 : 0;
pScene->mMaterials[idx] = new aiMaterial;
pScene->mMaterials[idx]->AddProperty(&texture_id, AI_MATKEY_TEXTURE_DIFFUSE(0));
pScene->mMaterials[idx]->AddProperty(&mode, 1, AI_MATKEY_TEXOP_DIFFUSE(0));
pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
idx++;
}
}// if(pScene->mNumTextures > 0)
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x628, %rsp # imm = 0x628
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
leaq 0x18(%rsp), %r15
movq %r15, 0x8(%r15)
movq %r15, (%r15)
xorl %eax, %eax
movq %rax, 0x10(%r15)
leaq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
movq %rax, 0x10(%rcx)
leaq 0x70(%rsp), %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
movq %rax, 0x10(%rcx)
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x2402f8
movq %r14, 0x8(%rbx)
movq $0x0, 0x448(%r14)
orb $0x20, (%rbx)
movq 0x10(%rsp), %rax
addq $0x80, %rax
movq %rax, %rcx
movq (%rcx), %rcx
cmpq %rax, %rcx
je 0x279ef6
movq 0x10(%rcx), %rbp
cmpl $0x9, 0x8(%rbp)
jne 0x2798d8
movq 0x38(%rbp), %r14
addq $0x38, %rbp
cmpq %rbp, %r14
je 0x27991b
movq 0x10(%r14), %rsi
cmpl $0x5, 0x8(%rsi)
jne 0x27990f
movq 0x10(%rsp), %rdi
callq 0x278760
movq (%r14), %r14
cmpq %rbp, %r14
jne 0x2798fb
movq (%rbp), %r14
cmpq %rbp, %r14
je 0x279989
leaq 0x220(%rsp), %r12
movq 0x10(%r14), %rsi
cmpl $0x8, 0x8(%rsi)
jne 0x27997d
movq $0x0, 0x220(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %r12, %rcx
callq 0x277476
movq 0x220(%rsp), %r13
testq %r13, %r13
je 0x27997d
movl $0x18, %edi
callq 0x1a5230
movq %r13, 0x10(%rax)
movq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x1a5360
incq 0x28(%rsp)
movq (%r14), %r14
cmpq %rbp, %r14
jne 0x279928
movq (%rbp), %r14
cmpq %rbp, %r14
je 0x2799e4
leaq 0x70(%rsp), %r12
movq 0x10(%r14), %r13
movl 0x8(%r13), %eax
cmpl $0x1, %eax
jne 0x2799b6
movq 0x10(%rsp), %rdi
movq %r13, %rsi
leaq 0x18(%rsp), %rdx
callq 0x278886
movl 0x8(%r13), %eax
cmpl $0x6, %eax
jne 0x2799dc
movl $0x18, %edi
callq 0x1a5230
movq %r13, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5360
incq 0x80(%rsp)
movq (%r14), %r14
cmpq %rbp, %r14
jne 0x279993
movq 0x8(%rbx), %rdx
leaq 0x70(%rsp), %rsi
callq 0x27726a
cmpq $0x2, 0x28(%rsp)
leaq 0x38(%rsp), %rsi
jb 0x279a5f
movq 0x18(%rsp), %r14
cmpq %r15, %r14
je 0x279a5f
movq %r14, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x279a33
movq 0x10(%r12), %rdi
movq 0x10(%r14), %rsi
addq $0x4, %rsi
callq 0x24056c
testq %rax, %rax
leaq 0x38(%rsp), %rsi
je 0x279a0c
jmp 0x279a38
movq (%r14), %r14
jmp 0x279a04
decq 0x28(%rsp)
movq %r14, %rdi
callq 0x1a6180
movl $0x18, %esi
movq %r14, %rdi
callq 0x1a5190
leaq 0x38(%rsp), %rsi
cmpq $0x1, 0x28(%rsp)
ja 0x2799ff
movq 0x18(%rsp), %r14
cmpq %r15, %r14
je 0x279adb
movl 0x28(%rsp), %eax
movq 0x8(%rbx), %rcx
movl %eax, 0x450(%rcx)
movq 0x8(%rbx), %r12
movl 0x450(%r12), %edi
shlq $0x3, %rdi
callq 0x1a57a0
movq %rax, 0x458(%r12)
movq 0x8(%rbx), %rcx
cmpl $0x0, 0x450(%rcx)
leaq 0x38(%rsp), %rsi
je 0x279adb
xorl %eax, %eax
movq 0x10(%r14), %rdx
movq %rcx, 0x448(%rdx)
movq 0x10(%r14), %rcx
movq (%r14), %r14
movq 0x8(%rbx), %rdx
movq 0x458(%rdx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
movq 0x8(%rbx), %rcx
movl 0x450(%rcx), %edx
cmpq %rdx, %rax
jb 0x279aa8
movq 0x38(%rsp), %r14
cmpq %rsi, %r14
je 0x279b2c
movq 0x48(%rsp), %r12
movl %r12d, 0x10(%rbx)
movq %r12, %rdi
shlq $0x3, %rdi
movabsq $0x7fffffff8, %rax # imm = 0x7FFFFFFF8
andq %rax, %rdi
callq 0x1a57a0
movq %rax, 0x18(%rbx)
testl %r12d, %r12d
je 0x279b2c
xorl %eax, %eax
movq 0x10(%r14), %rcx
movq (%r14), %r14
movq 0x18(%rbx), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
movl 0x10(%rbx), %ecx
cmpq %rcx, %rax
jb 0x279b12
movq 0x10(%rsp), %rax
movq 0xe8(%rax), %rdi
movl %edi, 0x40(%rbx)
testl %edi, %edi
je 0x279e7d
shlq $0x3, %rdi
movabsq $0x7fffffff8, %rax # imm = 0x7FFFFFFF8
andq %rax, %rdi
callq 0x1a57a0
movq 0x10(%rsp), %rcx
addq $0xd8, %rcx
movq %rax, 0x48(%rbx)
movq (%rcx), %r13
movq %rcx, 0x30(%rsp)
cmpq %rcx, %r13
je 0x279c11
xorl %ebp, %ebp
xorl %r12d, %r12d
movl $0x428, %edi # imm = 0x428
callq 0x1a5230
movq %rax, %r14
movq %rbp, (%rax)
movq %rbp, 0x18(%rax)
movl %ebp, 0x20(%rax)
movb $0x0, 0x24(%rax)
movq %rax, %rdi
addq $0x25, %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
movl %ebp, 0x8(%r14)
movq 0x48(%rbx), %rax
movq %r14, (%rax,%r12)
movl 0x30(%r13), %eax
movq 0x48(%rbx), %rcx
movq (%rcx,%r12), %rcx
movl %eax, (%rcx)
movl 0x38(%r13), %eax
movq 0x48(%rbx), %rcx
movq (%rcx,%r12), %rcx
movl %eax, 0x4(%rcx)
movq 0x58(%r13), %rax
movq 0x48(%rbx), %rcx
movq (%rcx,%r12), %rcx
movq %rax, 0x18(%rcx)
movq 0x48(%rbx), %rax
movq (%rax,%r12), %rdi
addq $0x8, %rdi
leaq 0x49(%r13), %rsi
callq 0x1a56e0
movq (%r13), %r13
addq $0x8, %r12
cmpq 0x30(%rsp), %r13
jne 0x279b7f
movq 0x10(%rsp), %rax
movq 0xe8(%rax), %rdi
movl %edi, 0x20(%rbx)
shlq $0x3, %rdi
movabsq $0x7fffffff8, %rax # imm = 0x7FFFFFFF8
andq %rax, %rdi
callq 0x1a57a0
movq %rax, 0x28(%rbx)
movq 0x30(%rsp), %rax
movq (%rax), %rbp
cmpq %rax, %rbp
je 0x279e7d
leaq 0x60(%rsp), %r14
xorl %r13d, %r13d
movq %rbx, 0x10(%rsp)
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a6170
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1a5850
leaq 0x88(%rsp), %r15
movq %r15, %rdi
leaq 0xb0(%rsp), %rsi
callq 0x1a5690
movq %rbx, %rdi
movq 0x5322fb(%rip), %rsi # 0x7abf90
callq 0x1a5d00
leaq 0x118(%rsp), %rdi
callq 0x1a5ca0
movl $0x1, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x2e56e1(%rip), %rcx # 0x55f39c
callq 0x1a5260
movq %r14, 0x50(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x279ce3
movq %rdx, 0x50(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
jmp 0x279cea
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %r15
movq 0x8(%rax), %rdx
movq %rdx, 0x58(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
xorl %ebx, %ebx
movb %bl, 0x10(%rax)
movq 0x50(%rsp), %r12
movq 0x58(%rsp), %r14
testl $0xfffffc00, %r14d # imm = 0xFFFFFC00
movl $0x3ff, %eax # imm = 0x3FF
cmovnel %eax, %r14d
movl %r14d, 0x220(%rsp)
leaq 0x224(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1a5110
movb %bl, 0x224(%rsp,%r14)
cmpq %r15, %r12
movq %r15, %r14
je 0x279d5b
movq 0x60(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x1a5190
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
leaq 0x18(%rsp), %r15
movq 0x10(%rsp), %rbx
je 0x279d8a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x0, 0xa8(%rsp)
movzbl 0x48(%rbp), %eax
movl %eax, 0x50(%rsp)
movl $0x10, %edi
callq 0x1a5230
movq %rax, %r12
movq %rax, %rdi
callq 0x2466d0
movq 0x28(%rbx), %rax
movq %r12, (%rax,%r13,8)
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rdi
leaq 0x220(%rsp), %rsi
leaq 0x316d23(%rip), %rdx # 0x590af4
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x246b54
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rdi
movl $0x4, (%rsp)
leaq 0xa8(%rsp), %rsi
movl $0x4, %edx
leaq 0x318464(%rip), %rcx # 0x592265
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rdi
movl $0x4, (%rsp)
leaq 0x50(%rsp), %rsi
movl $0x4, %edx
leaq 0x31843e(%rip), %rcx # 0x59226d
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %rdi
movl $0x4, (%rsp)
leaq 0x50(%rsp), %rsi
movl $0x4, %edx
leaq 0x31841e(%rip), %rcx # 0x59227b
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x2468bc
incq %r13
movq (%rbp), %rbp
cmpq 0x30(%rsp), %rbp
jne 0x279c58
movq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %r14
cmpq %r14, %rdi
je 0x279ea1
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x1a5190
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x279e8c
movq 0x38(%rsp), %rdi
leaq 0x38(%rsp), %r14
cmpq %r14, %rdi
je 0x279ec5
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x1a5190
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x279eb0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x279ee4
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x1a5190
movq %rbx, %rdi
cmpq %r15, %rbx
jne 0x279ecf
addq $0x628, %rsp # imm = 0x628
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x230(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x31d94b(%rip), %rsi # 0x597862
leaq 0x31d962(%rip), %rdx # 0x597880
leaq 0x220(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x220(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x4637f3(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x4637bf(%rip), %rsi # 0x6dd710
movq 0x532008(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x27a04c
jmp 0x27a04c
jmp 0x27a04c
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %r14, %rdi
jmp 0x279fd6
jmp 0x27a04c
jmp 0x27a04c
jmp 0x27a04c
jmp 0x27a04c
jmp 0x27a04c
movq %rax, %rbx
jmp 0x27a043
movq %rax, %rbx
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x27a043
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x27a043
movq %rax, %rbx
movl $0x10, %esi
movq %r12, %rdi
callq 0x1a5190
jmp 0x27a04f
jmp 0x27a04c
movq %rax, %rbx
movq 0x220(%rsp), %rdi
cmpq %r12, %rdi
je 0x279fff
movq 0x230(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
leaq 0x18(%rsp), %r15
jne 0x27a013
jmp 0x27a04f
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r14, %rdi
callq 0x1a6080
jmp 0x27a04f
jmp 0x27a04c
movq %rax, %rbx
movq 0x531f67(%rip), %rsi # 0x7abf90
leaq 0xa8(%rsp), %rdi
callq 0x1a5d00
leaq 0x118(%rsp), %rdi
callq 0x1a5ca0
leaq 0x18(%rsp), %r15
jmp 0x27a04f
jmp 0x27a04c
movq %rax, %rbx
movq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %r12
cmpq %r12, %rdi
je 0x27a073
movq (%rdi), %r14
movl $0x18, %esi
callq 0x1a5190
movq %r14, %rdi
cmpq %r12, %r14
jne 0x27a05e
movq 0x38(%rsp), %rdi
leaq 0x38(%rsp), %r12
cmpq %r12, %rdi
je 0x27a097
movq (%rdi), %r14
movl $0x18, %esi
callq 0x1a5190
movq %r14, %rdi
cmpq %r12, %r14
jne 0x27a082
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x27a0b6
movq (%rdi), %r14
movl $0x18, %esi
callq 0x1a5190
movq %r14, %rdi
cmpq %r15, %r14
jne 0x27a0a1
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/AMF/AMFImporter_Postprocess.cpp |
Assimp::AC3DImporter::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const | bool AC3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
{
std::string extension = GetExtension(pFile);
// fixme: are acc and ac3d *really* used? Some sources say they are
if(extension == "ac" || extension == "ac3d" || extension == "acc") {
return true;
}
if (!extension.length() || checkSig) {
uint32_t token = AI_MAKE_MAGIC("AC3D");
return CheckMagicToken(pIOHandler,pFile,&token,1,0);
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x24818a
leaq 0x2e75ff(%rip), %rsi # 0x56bf99
movq %rbx, %rdi
callq 0x1a60c0
movb $0x1, %bl
testl %eax, %eax
je 0x284a0a
leaq 0x3141e2(%rip), %rsi # 0x598b91
movq %rsp, %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x284a0a
leaq 0x313a0e(%rip), %rsi # 0x5983d0
movq %rsp, %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x284a0a
cmpq $0x0, 0x8(%rsp)
setne %al
xorb $0x1, %bpl
testb %bpl, %al
jne 0x284a08
leaq 0x24(%rsp), %rdx
movl $0x41433344, (%rdx) # imm = 0x41433344
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
movl $0x4, %r9d
callq 0x24821c
movl %eax, %ebx
jmp 0x284a0a
xorl %ebx, %ebx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x284a25
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x284a50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/AC/ACLoader.cpp |
void __gnu_cxx::new_allocator<Assimp::AC3DImporter::Object>::construct<Assimp::AC3DImporter::Object, Assimp::AC3DImporter::Object>(Assimp::AC3DImporter::Object*, Assimp::AC3DImporter::Object&&) | Object()
: type (World)
, name( "" )
, children()
, texture( "" )
, texRepeat( 1.f, 1.f )
, texOffset( 0.0f, 0.0f )
, rotation()
, translation()
, vertices()
, surfaces()
, numRefs (0)
, subDiv (0)
, crease()
{} | movl (%rdx), %eax
movl %eax, (%rsi)
leaq 0x18(%rsi), %rcx
movq %rcx, 0x8(%rsi)
movq 0x8(%rdx), %rdi
leaq 0x18(%rdx), %rax
cmpq %rax, %rdi
je 0x2893d8
movq %rdi, 0x8(%rsi)
movq (%rax), %rcx
movq %rcx, 0x18(%rsi)
jmp 0x2893de
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rsi)
movq %rax, 0x8(%rdx)
xorl %eax, %eax
movq %rax, 0x10(%rdx)
movb $0x0, 0x18(%rdx)
movq 0x28(%rdx), %rcx
movq %rcx, 0x28(%rsi)
movq 0x30(%rdx), %rcx
movq %rcx, 0x30(%rsi)
movq 0x38(%rdx), %rcx
movq %rcx, 0x38(%rsi)
movq %rax, 0x38(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdx)
leaq 0x50(%rsi), %rcx
movq %rcx, 0x40(%rsi)
movq 0x40(%rdx), %rdi
leaq 0x50(%rdx), %rax
cmpq %rax, %rdi
je 0x289439
movq %rdi, 0x40(%rsi)
movq (%rax), %rcx
movq %rcx, 0x50(%rsi)
jmp 0x28943f
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x48(%rdx), %rcx
movq %rcx, 0x48(%rsi)
movq %rax, 0x40(%rdx)
xorl %eax, %eax
movq %rax, 0x48(%rdx)
movb $0x0, 0x50(%rdx)
movups 0x60(%rdx), %xmm0
movups 0x70(%rdx), %xmm1
movups 0x80(%rdx), %xmm2
movups 0x90(%rdx), %xmm3
movups %xmm3, 0x90(%rsi)
movups %xmm2, 0x80(%rsi)
movups %xmm1, 0x70(%rsi)
movups %xmm0, 0x60(%rsi)
movq 0xa0(%rdx), %rcx
movq %rcx, 0xa0(%rsi)
movq 0xa8(%rdx), %rcx
movq %rcx, 0xa8(%rsi)
movq 0xb0(%rdx), %rcx
movq %rcx, 0xb0(%rsi)
movq %rax, 0xb0(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rdx)
movq 0xb8(%rdx), %rcx
movq %rcx, 0xb8(%rsi)
movq 0xc0(%rdx), %rcx
movq %rcx, 0xc0(%rsi)
movq 0xc8(%rdx), %rcx
movq %rcx, 0xc8(%rsi)
movq %rax, 0xc8(%rdx)
movups %xmm0, 0xb8(%rdx)
movl 0xd8(%rdx), %eax
movl %eax, 0xd8(%rsi)
movq 0xd0(%rdx), %rax
movq %rax, 0xd0(%rsi)
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/AC/ACLoader.h |
Assimp::ASEImporter::BuildNodes(std::vector<Assimp::ASE::BaseNode*, std::allocator<Assimp::ASE::BaseNode*>>&) | void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) {
ai_assert(NULL != pcScene);
// allocate the one and only root node
aiNode* root = pcScene->mRootNode = new aiNode();
root->mName.Set("<ASERoot>");
// Setup the coordinate system transformation
pcScene->mRootNode->mNumChildren = 1;
pcScene->mRootNode->mChildren = new aiNode*[1];
aiNode* ch = pcScene->mRootNode->mChildren[0] = new aiNode();
ch->mParent = root;
// Change the transformation matrix of all nodes
for (BaseNode *node : nodes) {
aiMatrix4x4& m = node->mTransform;
m.Transpose(); // row-order vs column-order
}
// add all nodes
AddNodes(nodes,ch,NULL);
// now iterate through al nodes and find those that have not yet
// been added to the nodegraph (= their parent could not be recognized)
std::vector<const BaseNode*> aiList;
for (std::vector<BaseNode*>::iterator it = nodes.begin(), end = nodes.end();it != end; ++it) {
if ((*it)->mProcessed) {
continue;
}
// check whether our parent is known
bool bKnowParent = false;
// search the list another time, starting *here* and try to find out whether
// there is a node that references *us* as a parent
for (std::vector<BaseNode*>::const_iterator it2 = nodes.begin();it2 != end; ++it2) {
if (it2 == it) {
continue;
}
if ((*it2)->mName == (*it)->mParent) {
bKnowParent = true;
break;
}
}
if (!bKnowParent) {
aiList.push_back(*it);
}
}
// Are there ane orphaned nodes?
if (!aiList.empty()) {
std::vector<aiNode*> apcNodes;
apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren);
for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren;++i)
apcNodes.push_back(pcScene->mRootNode->mChildren[i]);
delete[] pcScene->mRootNode->mChildren;
for (std::vector<const BaseNode*>::/*const_*/iterator i = aiList.begin();i != aiList.end();++i) {
const ASE::BaseNode* src = *i;
// The parent is not known, so we can assume that we must add
// this node to the root node of the whole scene
aiNode* pcNode = new aiNode();
pcNode->mParent = pcScene->mRootNode;
pcNode->mName.Set(src->mName);
AddMeshes(src,pcNode);
AddNodes(nodes,pcNode,pcNode->mName.data);
apcNodes.push_back(pcNode);
}
// Regenerate our output array
pcScene->mRootNode->mChildren = new aiNode*[apcNodes.size()];
for (unsigned int i = 0; i < apcNodes.size();++i)
pcScene->mRootNode->mChildren[i] = apcNodes[i];
pcScene->mRootNode->mNumChildren = (unsigned int)apcNodes.size();
}
// Reset the third color set to NULL - we used this field to store a temporary pointer
for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)
pcScene->mMeshes[i]->mColors[2] = NULL;
// The root node should not have at least one child or the file is valid
if (!pcScene->mRootNode->mNumChildren) {
throw DeadlyImportError("ASE: No nodes loaded. The file is either empty or corrupt");
}
// Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x38(%rsp)
cmpq $0x0, 0x88(%rdi)
je 0x28cc52
movq %rdi, %rbx
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r12
movq %rax, %rdi
callq 0x2402f8
movq 0x88(%rbx), %rax
movq %r12, 0x8(%rax)
movl $0x9, (%r12)
movabsq $0x746f6f524553413c, %rax # imm = 0x746F6F524553413C
movq %rax, 0x4(%r12)
movw $0x3e, 0xc(%r12)
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x450(%rax)
movl $0x8, %edi
callq 0x1a57a0
movq 0x88(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x458(%rcx)
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2402f8
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x458(%rax), %rax
movq %r15, (%rax)
movq %r12, 0x448(%r15)
movq 0x38(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x28c875
movq (%rax), %rdx
movss 0x58(%rdx), %xmm0
movss 0x4c(%rdx), %xmm1
movss 0x50(%rdx), %xmm2
movss %xmm1, 0x58(%rdx)
movss %xmm0, 0x4c(%rdx)
movss 0x68(%rdx), %xmm0
movss %xmm2, 0x68(%rdx)
movss %xmm0, 0x50(%rdx)
movss 0x6c(%rdx), %xmm0
movss 0x60(%rdx), %xmm1
movss %xmm1, 0x6c(%rdx)
movss %xmm0, 0x60(%rdx)
movss 0x78(%rdx), %xmm0
movss 0x54(%rdx), %xmm1
movss %xmm1, 0x78(%rdx)
movss %xmm0, 0x54(%rdx)
movss 0x64(%rdx), %xmm0
movss 0x7c(%rdx), %xmm1
movss %xmm0, 0x7c(%rdx)
movss %xmm1, 0x64(%rdx)
movss 0x74(%rdx), %xmm0
movss 0x80(%rdx), %xmm1
movss %xmm0, 0x80(%rdx)
movss %xmm1, 0x74(%rdx)
addq $0x8, %rax
jmp 0x28c7e2
movl $0x3f800000, %eax # imm = 0x3F800000
leaq 0x48(%rsp), %r8
movl %eax, (%r8)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%r8)
movl %eax, 0x14(%r8)
movups %xmm0, 0x18(%r8)
movl %eax, 0x28(%r8)
movups %xmm0, 0x2c(%r8)
movl %eax, 0x3c(%r8)
movq %rbx, %rdi
movq 0x38(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x28d9a4
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x28cba3
leaq 0x20(%rsp), %r12
movq (%r15), %r13
cmpb $0x0, 0x150(%r13)
jne 0x28c946
movq 0x38(%rsp), %rax
movq (%rax), %rbp
cmpq %r14, %rbp
je 0x28c924
cmpq %r15, %rbp
je 0x28c91e
movq (%rbp), %rax
movq 0x10(%rax), %rdx
cmpq 0x30(%r13), %rdx
jne 0x28c91e
testq %rdx, %rdx
je 0x28c946
movq 0x28(%r13), %rsi
movq 0x8(%rax), %rdi
callq 0x1a5c20
testl %eax, %eax
je 0x28c946
addq $0x8, %rbp
jmp 0x28c8f0
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x28c93b
movq %r13, (%rsi)
addq $0x8, 0x28(%rsp)
jmp 0x28c946
movq %r12, %rdi
movq %r15, %rdx
callq 0x28fcc2
addq $0x8, %r15
cmpq %r14, %r15
jne 0x28c8db
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
cmpq %rax, %rcx
je 0x28cba3
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
subq %rcx, %rax
sarq $0x3, %rax
movq 0x88(%rbx), %rcx
movq 0x8(%rcx), %rcx
movl 0x450(%rcx), %esi
addq %rax, %rsi
callq 0x28e9a2
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x450(%rax)
je 0x28c9f9
xorl %r14d, %r14d
movq %rsp, %r15
xorl %r12d, %r12d
movq 0x458(%rax), %rdx
addq %r14, %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x28c9d4
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x28c9dc
movq %r15, %rdi
callq 0x28fdfe
incq %r12
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rax
movl 0x450(%rax), %ecx
addq $0x8, %r14
cmpq %rcx, %r12
jb 0x28c9b0
movq 0x458(%rax), %rdi
testq %rdi, %rdi
je 0x28ca0a
callq 0x1a5610
movq 0x20(%rsp), %r15
cmpq 0x28(%rsp), %r15
je 0x28cb06
movl $0x3f800000, %r14d # imm = 0x3F800000
movq (%r15), %r12
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %rbp
movq %rax, %rdi
callq 0x2402f8
movq %rbp, 0x40(%rsp)
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x448(%rbp)
movq 0x10(%r12), %r13
cmpq $0x3ff, %r13 # imm = 0x3FF
ja 0x28ca7b
movl %r13d, (%rbp)
movq %rbp, %rdi
addq $0x4, %rdi
movq 0x8(%r12), %rsi
movq %r13, %rdx
callq 0x1a5110
movb $0x0, 0x4(%rbp,%r13)
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x28e094
movq 0x40(%rsp), %rdx
leaq 0x4(%rdx), %rcx
movl %r14d, 0x48(%rsp)
leaq 0x4c(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %r14d, 0x5c(%rsp)
movups %xmm0, 0x14(%rax)
movl %r14d, 0x70(%rsp)
movups %xmm0, 0x28(%rax)
movl %r14d, 0x84(%rsp)
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
leaq 0x48(%rsp), %r8
callq 0x28d9a4
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x28caea
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x28caf7
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x28fdfe
addq $0x8, %r15
cmpq 0x28(%rsp), %r15
jne 0x28ca20
movq (%rsp), %r14
movq 0x8(%rsp), %r12
movq %r12, %r15
subq %r14, %r15
movq $-0x1, %rdi
cmovnsq %r15, %rdi
callq 0x1a57a0
movq 0x88(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x458(%rcx)
cmpq %r14, %r12
je 0x28cb78
movl $0x1, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
movq 0x88(%rbx), %rsi
movq 0x8(%rsi), %rsi
movq 0x458(%rsi), %rsi
movq %rdx, (%rsi,%rcx,8)
movl %eax, %ecx
movq (%rsp), %r14
movq 0x8(%rsp), %r15
subq %r14, %r15
sarq $0x3, %r15
incl %eax
cmpq %rcx, %r15
ja 0x28cb43
jmp 0x28cb7c
sarq $0x3, %r15
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rax
movl %r15d, 0x450(%rax)
testq %r14, %r14
je 0x28cba3
movq 0x10(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x1a5190
movq 0x88(%rbx), %rax
cmpl $0x0, 0x10(%rax)
je 0x28cbd4
xorl %ecx, %ecx
movq 0x18(%rax), %rax
movq (%rax,%rcx,8), %rax
movq $0x0, 0x40(%rax)
incq %rcx
movq 0x88(%rbx), %rax
movl 0x10(%rax), %edx
cmpq %rdx, %rcx
jb 0x28cbb2
movq 0x8(%rax), %rax
cmpl $0x0, 0x450(%rax)
je 0x28cc71
movl $0x3f800000, 0x404(%rax) # imm = 0x3F800000
xorps %xmm0, %xmm0
movups %xmm0, 0x408(%rax)
movl $0x0, 0x418(%rax)
movaps 0x2ce956(%rip), %xmm1 # 0x55b560
movups %xmm1, 0x41c(%rax)
movups %xmm0, 0x42c(%rax)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, 0x43c(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x28cc40
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30c223(%rip), %rdi # 0x598e7c
leaq 0x30c0ae(%rip), %rsi # 0x598d0e
leaq 0x30c227(%rip), %rcx # 0x598e8e
movl $0x287, %edx # imm = 0x287
callq 0x1a5270
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x30c24a(%rip), %rsi # 0x598ed8
leaq 0x30c27c(%rip), %rdx # 0x598f11
leaq 0x48(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x450a82(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x450a4e(%rip), %rsi # 0x6dd710
movq 0x51f297(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x28cceb
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x28ccf5
jmp 0x28cd4d
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x28cd4d
jmp 0x28cd34
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %r15, %rdi
jmp 0x28cd5f
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %r12, %rdi
jmp 0x28cd5f
movq %rax, %rbx
jmp 0x28cd4d
jmp 0x28cd34
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %rbp, %rdi
callq 0x1a5190
jmp 0x28cd37
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x28cd4d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x28cd64
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/ASE/ASELoader.cpp |
Assimp::ASEImporter::AddMeshes(Assimp::ASE::BaseNode const*, aiNode*) | void ASEImporter::AddMeshes(const ASE::BaseNode* snode,aiNode* node)
{
for (unsigned int i = 0; i < pcScene->mNumMeshes;++i) {
// Get the name of the mesh (the mesh instance has been temporarily stored in the third vertex color)
const aiMesh* pcMesh = pcScene->mMeshes[i];
const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2];
if (mesh == snode) {
++node->mNumMeshes;
}
}
if(node->mNumMeshes) {
node->mMeshes = new unsigned int[node->mNumMeshes];
for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes;++i) {
const aiMesh* pcMesh = pcScene->mMeshes[i];
const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2];
if (mesh == snode) {
node->mMeshes[p++] = i;
// Transform all vertices of the mesh back into their local space ->
// at the moment they are pretransformed
aiMatrix4x4 m = mesh->mTransform;
m.Inverse();
aiVector3D* pvCurPtr = pcMesh->mVertices;
const aiVector3D* pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
while (pvCurPtr != pvEndPtr) {
*pvCurPtr = m * (*pvCurPtr);
pvCurPtr++;
}
// Do the same for the normal vectors, if we have them.
// As always, inverse transpose.
if (pcMesh->mNormals) {
aiMatrix3x3 m3 = aiMatrix3x3( mesh->mTransform );
m3.Transpose();
pvCurPtr = pcMesh->mNormals;
pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
while (pvCurPtr != pvEndPtr) {
*pvCurPtr = m3 * (*pvCurPtr);
pvCurPtr++;
}
}
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x88(%rdi), %rax
cmpl $0x0, 0x10(%rax)
je 0x28e0eb
xorl %ecx, %ecx
movq 0x18(%rax), %rsi
movq (%rsi,%rcx,8), %rsi
movq 0x40(%rsi), %rdi
leaq 0x48(%rdi), %rsi
testq %rdi, %rdi
cmoveq %rdi, %rsi
cmpq %r14, %rsi
jne 0x28e0e0
incl 0x460(%rdx)
movq 0x88(%r15), %rax
incq %rcx
movl 0x10(%rax), %esi
cmpq %rsi, %rcx
jb 0x28e0b7
movl 0x460(%rdx), %edi
testq %rdi, %rdi
je 0x28e32e
shlq $0x2, %rdi
movq %rdx, 0x8(%rsp)
callq 0x1a57a0
movq 0x8(%rsp), %rdx
movq %rax, 0x468(%rdx)
movq 0x88(%r15), %rax
cmpl $0x0, 0x10(%rax)
je 0x28e32e
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x18(%rax), %rcx
movq (%rcx,%r13,8), %rbx
movq 0x40(%rbx), %r12
leaq 0x48(%r12), %rcx
testq %r12, %r12
cmoveq %r12, %rcx
cmpq %r14, %rcx
jne 0x28e31f
movq 0x468(%rdx), %rax
movl %ebp, %ecx
movl %r13d, (%rax,%rcx,4)
movups 0x90(%r12), %xmm0
movups 0xa0(%r12), %xmm1
movups 0xb0(%r12), %xmm2
movups 0xc0(%r12), %xmm3
movaps %xmm3, 0x40(%rsp)
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x25b84e
movl 0x4(%rbx), %ecx
testq %rcx, %rcx
je 0x28e253
movq 0x10(%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,4), %rcx
movaps 0x10(%rsp), %xmm4
movups 0x14(%rsp), %xmm5
movss (%rax), %xmm1
movss 0x4(%rax), %xmm3
movups 0x18(%rsp), %xmm6
movss 0x8(%rax), %xmm0
movups 0x1c(%rsp), %xmm2
movaps %xmm3, %xmm7
unpcklps %xmm3, %xmm7 # xmm7 = xmm7[0],xmm3[0],xmm7[1],xmm3[1]
movss 0x24(%rsp), %xmm8
unpcklps %xmm8, %xmm5 # xmm5 = xmm5[0],xmm8[0],xmm5[1],xmm8[1]
mulps %xmm7, %xmm5
movss 0x20(%rsp), %xmm7
unpcklps %xmm7, %xmm4 # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1]
movaps %xmm1, %xmm7
unpcklps %xmm1, %xmm7 # xmm7 = xmm7[0],xmm1[0],xmm7[1],xmm1[1]
mulps %xmm4, %xmm7
addps %xmm5, %xmm7
movss 0x28(%rsp), %xmm4
unpcklps %xmm4, %xmm6 # xmm6 = xmm6[0],xmm4[0],xmm6[1],xmm4[1]
movaps %xmm0, %xmm4
unpcklps %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0],xmm4[1],xmm0[1]
mulps %xmm6, %xmm4
addps %xmm7, %xmm4
movss 0x2c(%rsp), %xmm5
unpcklps %xmm5, %xmm2 # xmm2 = xmm2[0],xmm5[0],xmm2[1],xmm5[1]
addps %xmm4, %xmm2
mulss 0x34(%rsp), %xmm3
mulss 0x30(%rsp), %xmm1
mulss 0x38(%rsp), %xmm0
addss %xmm3, %xmm1
addss %xmm1, %xmm0
addss 0x3c(%rsp), %xmm0
movlps %xmm2, (%rax)
movss %xmm0, 0x8(%rax)
addq $0xc, %rax
cmpq %rcx, %rax
jne 0x28e1b2
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x28e311
movl 0x4(%rbx), %ecx
testq %rcx, %rcx
je 0x28e311
movss 0x98(%r12), %xmm0
movss 0xa8(%r12), %xmm1
movsd 0x90(%r12), %xmm2
movsd 0xa0(%r12), %xmm3
movsd 0xb0(%r12), %xmm4
movss 0xb8(%r12), %xmm5
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,4), %rcx
movss (%rax), %xmm6
movss 0x4(%rax), %xmm7
movss 0x8(%rax), %xmm8
movaps %xmm1, %xmm9
mulss %xmm7, %xmm9
unpcklps %xmm7, %xmm7 # xmm7 = xmm7[0,0,1,1]
mulps %xmm3, %xmm7
movaps %xmm0, %xmm10
mulss %xmm6, %xmm10
unpcklps %xmm6, %xmm6 # xmm6 = xmm6[0,0,1,1]
mulps %xmm2, %xmm6
addps %xmm7, %xmm6
movaps %xmm5, %xmm7
mulss %xmm8, %xmm7
unpcklps %xmm8, %xmm8 # xmm8 = xmm8[0,0,1,1]
mulps %xmm4, %xmm8
addps %xmm6, %xmm8
addss %xmm9, %xmm10
addss %xmm7, %xmm10
movlps %xmm8, (%rax)
movss %xmm10, 0x8(%rax)
addq $0xc, %rax
cmpq %rcx, %rax
jne 0x28e2b0
incl %ebp
movq 0x88(%r15), %rax
movq 0x8(%rsp), %rdx
incq %r13
movl 0x10(%rax), %ecx
cmpq %rcx, %r13
jb 0x28e12a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/assimp/code/ASE/ASELoader.cpp |
Assimp::D3DS::Material::Material(Assimp::D3DS::Material const&) | Material(const Material &other) = default; | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbp
movq %rdi, %r13
leaq 0x44e77d(%rip), %rax # 0x6dea48
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x20ac60
movss 0x28(%rbp), %xmm0
movss %xmm0, 0x28(%r13)
movss 0x2c(%rbp), %xmm0
movss %xmm0, 0x2c(%r13)
movss 0x30(%rbp), %xmm0
movss %xmm0, 0x30(%r13)
movq 0x34(%rbp), %rax
movq %rax, 0x34(%r13)
movss 0x3c(%rbp), %xmm0
movss %xmm0, 0x3c(%r13)
movss 0x40(%rbp), %xmm0
movss %xmm0, 0x40(%r13)
movss 0x44(%rbp), %xmm0
movss %xmm0, 0x44(%r13)
movss 0x48(%rbp), %xmm0
movss %xmm0, 0x48(%r13)
movss 0x4c(%rbp), %xmm0
movss %xmm0, 0x4c(%r13)
movss 0x50(%rbp), %xmm0
movss %xmm0, 0x50(%r13)
movq 0x54(%rbp), %rax
movq %rax, 0x54(%r13)
movss 0x60(%rbp), %xmm0
movss %xmm0, 0x60(%r13)
leaq 0x68(%r13), %r14
leaq 0x78(%r13), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x68(%r13)
movq 0x68(%rbp), %rsi
movq 0x70(%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
movq %rbx, 0x60(%rsp)
callq 0x20ac60
movups 0x88(%rbp), %xmm0
movups 0x98(%rbp), %xmm1
movups %xmm1, 0x98(%r13)
movups %xmm0, 0x88(%r13)
movss 0xa8(%rbp), %xmm0
movss %xmm0, 0xa8(%r13)
leaq 0xb0(%r13), %r15
leaq 0xc0(%r13), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0xb0(%r13)
movq 0xb0(%rbp), %rsi
movq 0xb8(%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
movq %r14, 0x58(%rsp)
callq 0x20ac60
movups 0xd0(%rbp), %xmm0
movups 0xe0(%rbp), %xmm1
movups %xmm1, 0xe0(%r13)
movups %xmm0, 0xd0(%r13)
movss 0xf0(%rbp), %xmm0
movss %xmm0, 0xf0(%r13)
leaq 0xf8(%r13), %r12
leaq 0x108(%r13), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0xf8(%r13)
movq 0xf8(%rbp), %rsi
movq 0x100(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
movq %r15, 0x50(%rsp)
callq 0x20ac60
movups 0x118(%rbp), %xmm0
movups 0x128(%rbp), %xmm1
movups %xmm1, 0x128(%r13)
movups %xmm0, 0x118(%r13)
movss 0x138(%rbp), %xmm0
movss %xmm0, 0x138(%r13)
leaq 0x140(%r13), %rdi
leaq 0x150(%r13), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x140(%r13)
movq 0x140(%rbp), %rsi
movq 0x148(%rbp), %rdx
addq %rsi, %rdx
movq %rdi, 0x40(%rsp)
movq %r12, 0x48(%rsp)
callq 0x20ac60
movups 0x160(%rbp), %xmm0
movups 0x170(%rbp), %xmm1
movups %xmm1, 0x170(%r13)
movups %xmm0, 0x160(%r13)
movss 0x180(%rbp), %xmm0
movss %xmm0, 0x180(%r13)
leaq 0x188(%r13), %rdi
leaq 0x198(%r13), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x188(%r13)
movq 0x188(%rbp), %rsi
movq 0x190(%rbp), %rdx
addq %rsi, %rdx
movq %rdi, 0x38(%rsp)
callq 0x20ac60
movups 0x1a8(%rbp), %xmm0
movups 0x1b8(%rbp), %xmm1
movups %xmm1, 0x1b8(%r13)
movups %xmm0, 0x1a8(%r13)
movss 0x1c8(%rbp), %xmm0
movss %xmm0, 0x1c8(%r13)
leaq 0x1d0(%r13), %r15
leaq 0x1e0(%r13), %rbx
movq %rbx, 0x1d0(%r13)
movq 0x1d0(%rbp), %rsi
movq 0x1d8(%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x20ac60
movups 0x1f0(%rbp), %xmm0
movups 0x200(%rbp), %xmm1
movups %xmm1, 0x200(%r13)
movups %xmm0, 0x1f0(%r13)
movss 0x210(%rbp), %xmm0
movss %xmm0, 0x210(%r13)
leaq 0x218(%r13), %r12
leaq 0x228(%r13), %r14
movq %r14, 0x218(%r13)
movq 0x218(%rbp), %rsi
movq 0x220(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x20ac60
movups 0x238(%rbp), %xmm0
movups 0x248(%rbp), %xmm1
movups %xmm1, 0x248(%r13)
movups %xmm0, 0x238(%r13)
movss 0x258(%rbp), %xmm0
movss %xmm0, 0x258(%r13)
movss 0x25c(%rbp), %xmm0
movss %xmm0, 0x25c(%r13)
movss 0x260(%rbp), %xmm0
movss %xmm0, 0x260(%r13)
movss 0x264(%rbp), %xmm0
movss %xmm0, 0x264(%r13)
movss 0x268(%rbp), %xmm0
movss %xmm0, 0x268(%r13)
leaq 0x270(%r13), %rdi
leaq 0x280(%r13), %rax
movq %rax, 0x270(%r13)
movq 0x270(%rbp), %rsi
movq 0x278(%rbp), %rdx
addq %rsi, %rdx
callq 0x20ac60
movups 0x290(%rbp), %xmm0
movups 0x2a0(%rbp), %xmm1
movups %xmm1, 0x2a0(%r13)
movups %xmm0, 0x290(%r13)
movb 0x2b0(%rbp), %al
movb %al, 0x2b0(%r13)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x2906e2
movq (%r14), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2906e2
movq %rax, %r13
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x2906fa
movq (%rbx), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2906fa
movq %rax, %r13
movq 0x38(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x29071e
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
jmp 0x29071e
movq %rax, %r13
movq 0x40(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x290742
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
jmp 0x290742
movq %rax, %r13
movq 0x48(%rsp), %rax
movq (%rax), %rdi
cmpq 0x18(%rsp), %rdi
je 0x290766
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
jmp 0x290766
movq %rax, %r13
movq 0x50(%rsp), %rax
movq (%rax), %rdi
cmpq 0x20(%rsp), %rdi
je 0x29078a
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
jmp 0x29078a
movq %rax, %r13
movq 0x58(%rsp), %rax
movq (%rax), %rdi
cmpq 0x28(%rsp), %rdi
je 0x2907ae
movq 0x28(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2907ae
movq %rax, %r13
movq 0x60(%rsp), %rax
movq (%rax), %rdi
cmpq 0x30(%rsp), %rdi
je 0x2907cd
movq 0x30(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq %r13, %rdi
callq 0x1a5b90
nopl (%rax)
| /hbina[P]fatuous/thirdparty/assimp/code/3DS/3DSHelper.h |
Assimp::ASE::Parser::Parse() | void Parser::Parse()
{
AI_ASE_PARSER_INIT();
while (true)
{
if ('*' == *filePtr)
{
++filePtr;
// Version should be 200. Validate this ...
if (TokenMatch(filePtr,"3DSMAX_ASCIIEXPORT",18))
{
unsigned int fmt;
ParseLV4MeshLong(fmt);
if (fmt > 200)
{
LogWarning("Unknown file format version: *3DSMAX_ASCIIEXPORT should \
be <= 200");
}
// *************************************************************
// - fmt will be 0 if we're unable to read the version number
// there are some faulty files without a version number ...
// in this case we'll guess the exact file format by looking
// at the file extension (ASE, ASK, ASC)
// *************************************************************
if ( fmt ) {
iFileFormat = fmt;
}
continue;
}
// main scene information
if (TokenMatch(filePtr,"SCENE",5))
{
ParseLV1SceneBlock();
continue;
}
// "group" - no implementation yet, in facte
// we're just ignoring them for the moment
if (TokenMatch(filePtr,"GROUP",5))
{
Parse();
continue;
}
// material list
if (TokenMatch(filePtr,"MATERIAL_LIST",13))
{
ParseLV1MaterialListBlock();
continue;
}
// geometric object (mesh)
if (TokenMatch(filePtr,"GEOMOBJECT",10))
{
m_vMeshes.push_back(Mesh("UNNAMED"));
ParseLV1ObjectBlock(m_vMeshes.back());
continue;
}
// helper object = dummy in the hierarchy
if (TokenMatch(filePtr,"HELPEROBJECT",12))
{
m_vDummies.push_back(Dummy());
ParseLV1ObjectBlock(m_vDummies.back());
continue;
}
// light object
if (TokenMatch(filePtr,"LIGHTOBJECT",11))
{
m_vLights.push_back(Light("UNNAMED"));
ParseLV1ObjectBlock(m_vLights.back());
continue;
}
// camera object
if (TokenMatch(filePtr,"CAMERAOBJECT",12))
{
m_vCameras.push_back(Camera("UNNAMED"));
ParseLV1ObjectBlock(m_vCameras.back());
continue;
}
// comment - print it on the console
if (TokenMatch(filePtr,"COMMENT",7))
{
std::string out = "<unknown>";
ParseString(out,"*COMMENT");
LogInfo(("Comment: " + out).c_str());
continue;
}
// ASC bone weights
if (AI_ASE_IS_OLD_FILE_FORMAT() && TokenMatch(filePtr,"MESH_SOFTSKINVERTS",18))
{
ParseLV1SoftSkinBlock();
}
}
AI_ASE_HANDLE_TOP_LEVEL_SECTION();
}
return;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x40(%rsp)
leaq 0x50(%rdi), %rax
movq %rax, 0x38(%rsp)
leaq 0x68(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x80(%rdi), %rax
movq %rax, 0x28(%rsp)
xorl %r12d, %r12d
movabsq $0x100003601, %r15 # imm = 0x100003601
movl $0x3401, %r13d # imm = 0x3401
movq (%rbx), %rbp
movzbl (%rbp), %eax
cmpl $0x7a, %eax
jle 0x290b62
cmpl $0x7b, %eax
je 0x290c9c
cmpl $0x7d, %eax
jne 0x290ca9
decl %r12d
jne 0x290ca9
jmp 0x291140
cmpl $0x2a, %eax
jne 0x290ca1
leaq 0x1(%rbp), %r14
movq %r14, (%rbx)
movl $0x12, %edx
leaq 0x3086f3(%rip), %rdi # 0x599271
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290ce2
movl $0x5, %edx
leaq 0x30874b(%rip), %rdi # 0x5992e5
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290d35
movl $0x5, %edx
leaq 0x308735(%rip), %rdi # 0x5992eb
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290d6b
movl $0xd, %edx
leaq 0x30871f(%rip), %rdi # 0x5992f1
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290db4
movl $0xa, %edx
leaq 0x308711(%rip), %rdi # 0x5992ff
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290dea
movl $0xc, %edx
leaq 0x308700(%rip), %rdi # 0x59930a
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290e89
movl $0xb, %edx
leaq 0x3086f1(%rip), %rdi # 0x599317
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290ee4
movl $0xc, %edx
leaq 0x3086e1(%rip), %rdi # 0x599323
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x290faf
movl $0x7, %edx
leaq 0x3086dd(%rip), %rdi # 0x59933b
movq %r14, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x29107e
cmpl $0xc7, 0xb0(%rbx)
ja 0x290ca9
movq %rbx, %rdi
leaq 0x3086bf(%rip), %rsi # 0x599343
movl $0x12, %edx
callq 0x288a50
testb %al, %al
je 0x290ca9
movq %rbx, %rdi
callq 0x291ff2
jmp 0x290ca9
incl %r12d
jmp 0x290ca9
testl %eax, %eax
je 0x29114e
movq (%rbx), %rax
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0xd, %edx
ja 0x290cd1
btl %edx, %r13d
jae 0x290cd1
cmpb $0x0, 0xac(%rbx)
je 0x290cc9
xorl %ecx, %ecx
jmp 0x290cd1
incl 0x98(%rbx)
movb $0x1, %cl
movb %cl, 0xac(%rbx)
incq %rax
movq %rax, (%rbx)
jmp 0x290b36
movzbl 0x13(%rbp), %eax
cmpq $0x20, %rax
ja 0x290b8e
btq %rax, %r15
jae 0x290b8e
leaq 0x13(%rbp), %rcx
addq $0x14, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
movq %rbx, %rdi
leaq 0x48(%rsp), %rsi
callq 0x291202
movl 0x48(%rsp), %ebp
cmpl $0xc9, %ebp
jb 0x290da1
movq %rbx, %rdi
leaq 0x308556(%rip), %rsi # 0x599284
callq 0x290850
jmp 0x290da9
movzbl 0x6(%rbp), %eax
cmpq $0x20, %rax
ja 0x290baa
btq %rax, %r15
jae 0x290baa
leaq 0x6(%rbp), %rcx
addq $0x7, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
movq %rbx, %rdi
callq 0x29128a
jmp 0x290b36
movzbl 0x6(%rbp), %eax
cmpq $0x20, %rax
ja 0x290bc6
btq %rax, %r15
jae 0x290bc6
leaq 0x6(%rbp), %rcx
addq $0x7, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
movq %rbx, %rdi
callq 0x290ae8
jmp 0x290b36
testl %ebp, %ebp
je 0x290b36
movl %ebp, 0xb0(%rbx)
jmp 0x290b36
movzbl 0xe(%rbp), %eax
cmpq $0x20, %rax
ja 0x290be2
btq %rax, %r15
jae 0x290be2
leaq 0xe(%rbp), %rcx
addq $0xf, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
movq %rbx, %rdi
callq 0x291586
jmp 0x290b36
movzbl 0xb(%rbp), %eax
cmpq $0x20, %rax
ja 0x290bfe
btq %rax, %r15
jae 0x290bfe
leaq 0xb(%rbp), %rcx
addq $0xc, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
leaq 0x306d81(%rip), %rsi # 0x597bad
leaq 0x306d81(%rip), %rdx # 0x597bb4
callq 0x209290
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x296ffe
movq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x2975b6
movq %r14, %rdi
callq 0x28f410
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x290e79
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x40(%rbx), %rsi
movq $-0x288, %rax # imm = 0xFD78
jmp 0x29106e
movzbl 0xd(%rbp), %eax
cmpq $0x20, %rax
ja 0x290c1a
btq %rax, %r15
jae 0x290c1a
leaq 0xd(%rbp), %rcx
addq $0xe, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x297084
movq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x297b8a
movq %r14, %rdi
callq 0x28f336
movq 0x58(%rbx), %rsi
movq $-0x158, %rax # imm = 0xFEA8
jmp 0x29106e
movzbl 0xc(%rbp), %eax
cmpq $0x20, %rax
ja 0x290c36
btq %rax, %r15
jae 0x290c36
leaq 0xc(%rbp), %rcx
addq $0xd, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
leaq 0x306c87(%rip), %rsi # 0x597bad
leaq 0x306c87(%rip), %rdx # 0x597bb4
callq 0x209290
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x29741a
movl $0x0, 0x19c(%rsp)
movaps 0x2d19da(%rip), %xmm0 # 0x562930
movups %xmm0, 0x1a0(%rsp)
movss 0x302722(%rip), %xmm0 # 0x593688
movlps %xmm0, 0x1b0(%rsp)
movq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x297d6c
movq %r14, %rdi
callq 0x28f336
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x290f9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x70(%rbx), %rsi
movq $-0x170, %rax # imm = 0xFE90
jmp 0x29106e
movzbl 0xd(%rbp), %eax
cmpq $0x20, %rax
ja 0x290c52
btq %rax, %r15
jae 0x290c52
leaq 0xd(%rbp), %rcx
addq $0xe, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
leaq 0x306bbc(%rip), %rsi # 0x597bad
leaq 0x306bbc(%rip), %rdx # 0x597bb4
callq 0x209290
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
movq %rbp, %rdx
callq 0x29741a
movsd 0x308076(%rip), %xmm0 # 0x599090
movsd %xmm0, 0x19c(%rsp)
movq $0x447a0000, 0x1a4(%rsp) # imm = 0x447A0000
movq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x2984b4
movq %r14, %rdi
callq 0x28f336
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x291060
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x88(%rbx), %rsi
movq $-0x168, %rax # imm = 0xFE98
addq %rax, %rsi
movq %rbx, %rdi
callq 0x291864
jmp 0x290b36
movzbl 0x8(%rbp), %eax
cmpq $0x20, %rax
ja 0x290c6e
btq %rax, %r15
jae 0x290c6e
leaq 0x8(%rbp), %rcx
addq $0x9, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
leaq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
leaq 0x308270(%rip), %rsi # 0x599330
leaq 0x308272(%rip), %rdx # 0x599339
callq 0x209290
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x308261(%rip), %rdx # 0x59933a
callq 0x291ef8
leaq 0x8(%rsp), %rdi
leaq 0x30c4d6(%rip), %rsi # 0x59d5c0
movq %r14, %rdx
callq 0x23ca59
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2908b8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x29111b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x290b36
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x290b36
incq %rbp
movq %rbp, (%rbx)
movq %rbx, %rdi
callq 0x290a0a
addq $0x318, %rsp # imm = 0x318
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x291186
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x291186
jmp 0x291183
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2911f9
movq 0x58(%rsp), %rsi
jmp 0x2911ec
jmp 0x2911f6
jmp 0x2911a4
jmp 0x2911d5
jmp 0x2911f6
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x28f336
jmp 0x2911d8
jmp 0x2911d5
jmp 0x2911f6
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x28f336
jmp 0x2911f9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x28f410
jmp 0x2911d8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2911f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2911f9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/ASE/ASEParser.cpp |
Assimp::ASE::Parser::ParseLV4MeshLong(unsigned int&) | void Parser::ParseLV4MeshLong(unsigned int& iOut)
{
// Skip spaces and tabs
if(!SkipSpaces(&filePtr))
{
// LOG
LogWarning("Unable to parse long: unexpected EOL [#1]");
iOut = 0;
++iLineNumber;
return;
}
// parse the value
iOut = strtoul10(filePtr,&filePtr);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x29121c
cmpl $0x9, %ecx
jne 0x291221
incq %rax
jmp 0x29120f
movq %rax, (%r14)
movzbl (%rax), %ecx
cmpl $0xd, %ecx
ja 0x29125a
movl $0x3401, %edx # imm = 0x3401
btl %ecx, %edx
jae 0x29125a
leaq 0x3096ac(%rip), %rsi # 0x59a8e9
movq %r14, %rdi
callq 0x290850
movl $0x0, (%rbx)
incl 0x98(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leal -0x3a(%rcx), %esi
xorl %edx, %edx
cmpb $-0xa, %sil
jb 0x291282
xorl %edx, %edx
leal (%rdx,%rdx,4), %edx
addb $-0x30, %cl
movzbl %cl, %ecx
leal (%rcx,%rdx,2), %edx
movb 0x1(%rax), %cl
incq %rax
leal -0x3a(%rcx), %esi
cmpb $-0xb, %sil
ja 0x291267
movq %rax, (%r14)
movl %edx, (%rbx)
jmp 0x291252
nop
| /hbina[P]fatuous/thirdparty/assimp/code/ASE/ASEParser.cpp |
Assimp::ASE::Parser::ParseLV4MeshFloat(float&) | void Parser::ParseLV4MeshFloat(ai_real& fOut)
{
// skip spaces and tabs
if(!SkipSpaces(&filePtr))
{
// LOG
LogWarning("Unable to parse float: unexpected EOL [#1]");
fOut = 0.0;
++iLineNumber;
return;
}
// parse the first float
filePtr = fast_atoreal_move<ai_real>(filePtr,fOut);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movzbl (%rdi), %eax
cmpl $0x20, %eax
je 0x292546
cmpl $0x9, %eax
jne 0x29254b
incq %rdi
jmp 0x292539
movq %rdi, (%rbx)
movzbl (%rdi), %eax
cmpl $0xd, %eax
ja 0x292584
movl $0x3401, %ecx # imm = 0x3401
btl %eax, %ecx
jae 0x292584
leaq 0x308357(%rip), %rsi # 0x59a8be
movq %rbx, %rdi
callq 0x290850
movl $0x0, (%r14)
incl 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rsi
movl $0x1, %edx
callq 0x2470c9
movq %rax, (%rbx)
jmp 0x29257c
| /hbina[P]fatuous/thirdparty/assimp/code/ASE/ASEParser.cpp |
Assimp::ASE::Parser::ParseLV3PosAnimationBlock(Assimp::ASE::Animation&) | void Parser::ParseLV3PosAnimationBlock(ASE::Animation& anim)
{
AI_ASE_PARSER_INIT();
unsigned int iIndex;
while (true)
{
if ('*' == *filePtr)
{
++filePtr;
bool b = false;
// For the moment we're just reading the three floats -
// we ignore the additional information for bezier's and TCBs
// simple scaling keyframe
if (TokenMatch(filePtr,"CONTROL_POS_SAMPLE" ,18))
{
b = true;
anim.mPositionType = ASE::Animation::TRACK;
}
// Bezier scaling keyframe
if (TokenMatch(filePtr,"CONTROL_BEZIER_POS_KEY" ,22))
{
b = true;
anim.mPositionType = ASE::Animation::BEZIER;
}
// TCB scaling keyframe
if (TokenMatch(filePtr,"CONTROL_TCB_POS_KEY" ,19))
{
b = true;
anim.mPositionType = ASE::Animation::TCB;
}
if (b)
{
anim.akeyPositions.push_back(aiVectorKey());
aiVectorKey& key = anim.akeyPositions.back();
ParseLV4MeshFloatTriple(&key.mValue.x,iIndex);
key.mTime = (double)iIndex;
}
}
AI_ASE_HANDLE_SECTION("3","*CONTROL_POS_TRACK");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %rax
movq %rax, 0x8(%rsp)
movq (%rdi), %rbp
xorl %r12d, %r12d
movb (%rbp), %al
cmpb $0x2a, %al
jne 0x294dcc
leaq 0x1(%rbp), %r15
movq %r15, (%rbx)
movl $0x12, %edx
leaq 0x304fa7(%rip), %rdi # 0x599c06
movq %r15, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x294c70
xorl %r13d, %r13d
jmp 0x294cac
movzbl 0x13(%rbp), %eax
xorl %r13d, %r13d
cmpq $0x20, %rax
ja 0x294cac
movabsq $0x100003601, %rcx # imm = 0x100003601
btq %rax, %rcx
jae 0x294cac
leaq 0x13(%rbp), %rcx
addq $0x14, %rbp
testb %al, %al
cmoveq %rcx, %rbp
movq %rbp, (%rbx)
movl $0x0, 0x8(%r14)
movq (%rbx), %r15
movb $0x1, %r13b
movl $0x16, %edx
leaq 0x304f61(%rip), %rdi # 0x599c19
movq %r15, %rsi
callq 0x1a53a0
testl %eax, %eax
jne 0x294cfe
movzbl 0x16(%r15), %eax
cmpq $0x20, %rax
ja 0x294cfe
movabsq $0x100003601, %rcx # imm = 0x100003601
btq %rax, %rcx
jae 0x294cfe
leaq 0x16(%r15), %rcx
addq $0x17, %r15
testb %al, %al
cmoveq %rcx, %r15
movq %r15, (%rbx)
movl $0x1, 0x8(%r14)
movq (%rbx), %r15
movb $0x1, %r13b
movl $0x13, %edx
leaq 0x304f26(%rip), %rdi # 0x599c30
movq %r15, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x294d24
testb %r13b, %r13b
xorpd %xmm0, %xmm0
jne 0x294d5c
jmp 0x294dc6
movzbl 0x13(%r15), %eax
cmpq $0x20, %rax
ja 0x294d16
movabsq $0x100003601, %rcx # imm = 0x100003601
btq %rax, %rcx
jae 0x294d16
leaq 0x13(%r15), %rcx
addq $0x14, %r15
testb %al, %al
cmoveq %rcx, %r15
movq %r15, (%rbx)
movl $0x2, 0x8(%r14)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x30(%r14), %rsi
cmpq 0x38(%r14), %rsi
je 0x294d8d
movupd %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movq 0x30(%r14), %r15
addq $0x18, %r15
movq %r15, 0x30(%r14)
jmp 0x294da0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x299a32
movq 0x30(%r14), %r15
leaq -0x10(%r15), %rsi
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x295386
movl 0x4(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x18(%r15)
movq (%rbx), %r15
movb (%r15), %al
movq %r15, %rbp
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x7a, %ecx
jg 0x294df6
leal -0xc(%rcx), %edx
cmpl $0x2, %edx
jb 0x294de3
cmpl $0xa, %ecx
jne 0x294e1d
cmpb $0x0, 0xac(%rbx)
jne 0x294e0a
incl 0x98(%rbx)
movb $0x1, %al
jmp 0x294e0c
cmpl $0x7d, %ecx
je 0x294e05
cmpl $0x7b, %ecx
jne 0x294e0c
incl %r12d
jmp 0x294e0a
decl %r12d
je 0x294e30
xorl %eax, %eax
movb %al, 0xac(%rbx)
incq %rbp
movq %rbp, (%rbx)
jmp 0x294c41
testl %ecx, %ecx
jne 0x294e0c
leaq 0x304d90(%rip), %rsi # 0x599bb8
movq %rbx, %rdi
callq 0x290920
incq %rbp
movq %rbp, (%rbx)
movq %rbx, %rdi
callq 0x290a0a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/ASE/ASEParser.cpp |
Assimp::ASE::Parser::ParseLV3MappingChannel(unsigned int, Assimp::ASE::Mesh&) | void Parser::ParseLV3MappingChannel(unsigned int iChannel, ASE::Mesh& mesh)
{
AI_ASE_PARSER_INIT();
unsigned int iNumTVertices = 0;
unsigned int iNumTFaces = 0;
while (true)
{
if ('*' == *filePtr)
{
++filePtr;
// Number of texture coordinates in the mesh
if (TokenMatch(filePtr,"MESH_NUMTVERTEX" ,15))
{
ParseLV4MeshLong(iNumTVertices);
continue;
}
// Number of UVWed faces in the mesh
if (TokenMatch(filePtr,"MESH_NUMTVFACES" ,15))
{
ParseLV4MeshLong(iNumTFaces);
continue;
}
// mesh texture vertex list block
if (TokenMatch(filePtr,"MESH_TVERTLIST" ,14))
{
ParseLV3MeshTListBlock(iNumTVertices,mesh,iChannel);
continue;
}
// mesh texture face block
if (TokenMatch(filePtr,"MESH_TFACELIST" ,14))
{
ParseLV3MeshTFaceListBlock(iNumTFaces,mesh, iChannel);
continue;
}
}
AI_ASE_HANDLE_SECTION("3","*MESH_MAPPING_CHANNEL");
}
return;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0xc(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x8(%rsp), %rcx
movl $0x0, 0x4(%rsp)
movl %eax, (%rcx)
movq (%rdi), %r14
leaq 0x303bc9(%rip), %r13 # 0x599dd1
movabsq $0x100003601, %r12 # imm = 0x100003601
movb (%r14), %al
cmpb $0x2a, %al
jne 0x296392
leaq 0x1(%r14), %r15
movq %r15, (%rbx)
movl $0xf, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x2962d2
movl $0xf, %edx
leaq 0x303bb7(%rip), %rdi # 0x599dff
movq %r15, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x296306
movl $0xe, %edx
leaq 0x303bdb(%rip), %rdi # 0x599e3f
movq %r15, %rsi
callq 0x1a53a0
testl %eax, %eax
je 0x29633f
movl $0xe, %edx
leaq 0x303bce(%rip), %rdi # 0x599e4e
movq %r15, %rsi
callq 0x1a53a0
testl %eax, %eax
jne 0x29638c
movzbl 0xf(%r14), %eax
cmpq $0x20, %rax
ja 0x29638c
btq %rax, %r12
jae 0x29638c
leaq 0xf(%r14), %rcx
addq $0x10, %r14
testb %al, %al
cmoveq %rcx, %r14
movq %r14, (%rbx)
movl 0x8(%rsp), %esi
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
callq 0x295914
jmp 0x29637c
movzbl 0x10(%r14), %eax
cmpq $0x20, %rax
ja 0x29623c
btq %rax, %r12
jae 0x29623c
leaq 0x10(%r14), %rcx
addq $0x11, %r14
testb %al, %al
cmoveq %rcx, %r14
movq %r14, (%rbx)
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
jmp 0x296338
movzbl 0x10(%r14), %eax
cmpq $0x20, %rax
ja 0x296258
btq %rax, %r12
jae 0x296258
leaq 0x10(%r14), %rcx
addq $0x11, %r14
testb %al, %al
cmoveq %rcx, %r14
movq %r14, (%rbx)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x291202
jmp 0x29637c
movzbl 0xf(%r14), %eax
cmpq $0x20, %rax
ja 0x296274
btq %rax, %r12
jae 0x296274
leaq 0xf(%r14), %rcx
addq $0x10, %r14
testb %al, %al
cmoveq %rcx, %r14
movq %r14, (%rbx)
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movl %ebp, %ecx
callq 0x295758
movq (%rbx), %r14
cmpb $0x2a, (%r14)
movq %r14, %r15
je 0x29621d
movb (%r15), %al
movq %r15, %r14
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x7a, %ecx
jg 0x2963bc
leal -0xc(%rcx), %edx
cmpl $0x2, %edx
jb 0x2963a9
cmpl $0xa, %ecx
jne 0x2963eb
cmpb $0x0, 0xac(%rbx)
jne 0x2963d8
incl 0x98(%rbx)
movb $0x1, %al
jmp 0x2963da
cmpl $0x7d, %ecx
je 0x2963cc
cmpl $0x7b, %ecx
jne 0x2963da
incl 0x4(%rsp)
jmp 0x2963d8
movl 0x4(%rsp), %eax
decl %eax
je 0x2963fe
movl %eax, 0x4(%rsp)
xorl %eax, %eax
movb %al, 0xac(%rbx)
incq %r14
movq %r14, (%rbx)
jmp 0x296212
testl %ecx, %ecx
jne 0x2963da
leaq 0x303f79(%rip), %rsi # 0x59a36f
movq %rbx, %rdi
callq 0x290920
incq %r14
movq %r14, (%rbx)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x290a0a
| /hbina[P]fatuous/thirdparty/assimp/code/ASE/ASEParser.cpp |
Assimp::D3DS::Material::operator=(Assimp::D3DS::Material&&) | Material &operator=(Material &&other) AI_NO_EXCEPT {
if (this == &other) {
return *this;
}
mName = std::move(other.mName);
mDiffuse = std::move(other.mDiffuse);
mSpecularExponent = std::move(other.mSpecularExponent);
mShininessStrength = std::move(other.mShininessStrength),
mSpecular = std::move(other.mSpecular);
mAmbient = std::move(other.mAmbient);
mShading = std::move(other.mShading);
mTransparency = std::move(other.mTransparency);
sTexDiffuse = std::move(other.sTexDiffuse);
sTexOpacity = std::move(other.sTexOpacity);
sTexSpecular = std::move(other.sTexSpecular);
sTexReflective = std::move(other.sTexReflective);
sTexBump = std::move(other.sTexBump);
sTexEmissive = std::move(other.sTexEmissive);
sTexShininess = std::move(other.sTexShininess);
mBumpHeight = std::move(other.mBumpHeight);
mEmissive = std::move(other.mEmissive);
sTexAmbient = std::move(other.sTexAmbient);
mTwoSided = std::move(other.mTwoSided);
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x29939c
movq %rsi, %r14
addq $0x8, %rsi
leaq 0x8(%rbx), %rdi
callq 0x1a58d0
movss 0x28(%r14), %xmm0
movss %xmm0, 0x28(%rbx)
movss 0x2c(%r14), %xmm0
movss %xmm0, 0x2c(%rbx)
movss 0x30(%r14), %xmm0
movss %xmm0, 0x30(%rbx)
movss 0x34(%r14), %xmm0
movss %xmm0, 0x34(%rbx)
movss 0x38(%r14), %xmm0
movss %xmm0, 0x38(%rbx)
movss 0x3c(%r14), %xmm0
movss %xmm0, 0x3c(%rbx)
movss 0x40(%r14), %xmm0
movss %xmm0, 0x40(%rbx)
movss 0x44(%r14), %xmm0
movss %xmm0, 0x44(%rbx)
movss 0x48(%r14), %xmm0
movss %xmm0, 0x48(%rbx)
movss 0x4c(%r14), %xmm0
movss %xmm0, 0x4c(%rbx)
movss 0x50(%r14), %xmm0
movss %xmm0, 0x50(%rbx)
movl 0x54(%r14), %eax
movl %eax, 0x54(%rbx)
movss 0x58(%r14), %xmm0
movss %xmm0, 0x58(%rbx)
movss 0x60(%r14), %xmm0
movss %xmm0, 0x60(%rbx)
leaq 0x68(%rbx), %rdi
leaq 0x68(%r14), %rsi
callq 0x1a58d0
movups 0x88(%r14), %xmm0
movups 0x98(%r14), %xmm1
movups %xmm0, 0x88(%rbx)
movups %xmm1, 0x98(%rbx)
movss 0xa8(%r14), %xmm0
movss %xmm0, 0xa8(%rbx)
movl $0xb0, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x1a58d0
movups 0xd0(%r14), %xmm0
movups 0xe0(%r14), %xmm1
movups %xmm0, 0xd0(%rbx)
movups %xmm1, 0xe0(%rbx)
movss 0xf0(%r14), %xmm0
movss %xmm0, 0xf0(%rbx)
movl $0xf8, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x1a58d0
movups 0x118(%r14), %xmm0
movups 0x128(%r14), %xmm1
movups %xmm0, 0x118(%rbx)
movups %xmm1, 0x128(%rbx)
movss 0x138(%r14), %xmm0
movss %xmm0, 0x138(%rbx)
movl $0x140, %esi # imm = 0x140
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x1a58d0
movups 0x160(%r14), %xmm0
movups 0x170(%r14), %xmm1
movups %xmm0, 0x160(%rbx)
movups %xmm1, 0x170(%rbx)
movss 0x180(%r14), %xmm0
movss %xmm0, 0x180(%rbx)
movl $0x188, %esi # imm = 0x188
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x1a58d0
movups 0x1a8(%r14), %xmm0
movups 0x1b8(%r14), %xmm1
movups %xmm0, 0x1a8(%rbx)
movups %xmm1, 0x1b8(%rbx)
movss 0x1c8(%r14), %xmm0
movss %xmm0, 0x1c8(%rbx)
movl $0x1d0, %esi # imm = 0x1D0
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x1a58d0
movups 0x1f0(%r14), %xmm0
movups 0x200(%r14), %xmm1
movups %xmm0, 0x1f0(%rbx)
movups %xmm1, 0x200(%rbx)
movss 0x210(%r14), %xmm0
movss %xmm0, 0x210(%rbx)
movl $0x218, %esi # imm = 0x218
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x1a58d0
movups 0x238(%r14), %xmm0
movups 0x248(%r14), %xmm1
movups %xmm0, 0x238(%rbx)
movups %xmm1, 0x248(%rbx)
movss 0x258(%r14), %xmm0
movss %xmm0, 0x258(%rbx)
movss 0x25c(%r14), %xmm0
movss %xmm0, 0x25c(%rbx)
movss 0x260(%r14), %xmm0
movss %xmm0, 0x260(%rbx)
movss 0x264(%r14), %xmm0
movss %xmm0, 0x264(%rbx)
movss 0x268(%r14), %xmm0
movss %xmm0, 0x268(%rbx)
movl $0x270, %esi # imm = 0x270
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x1a58d0
movups 0x290(%r14), %xmm0
movups 0x2a0(%r14), %xmm1
movups %xmm0, 0x290(%rbx)
movups %xmm1, 0x2a0(%rbx)
movb 0x2b0(%r14), %al
movb %al, 0x2b0(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/3DS/3DSHelper.h |
Assimp::AssbinImporter::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const | bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const {
IOStream * in = pIOHandler->Open(pFile);
if (nullptr == in) {
return false;
}
char s[32];
in->Read( s, sizeof(char), 32 );
pIOHandler->Close(in);
return strncmp( s, "ASSIMP.binary-dump.", 19 ) == 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x310417(%rip), %rsi # 0x5aa761
leaq 0x310412(%rip), %rdx # 0x5aa763
movq %rsp, %r15
movq %r15, %rdi
callq 0x209290
movq (%r14), %rsi
movq (%r15), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29a384
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
testq %r14, %r14
je 0x29a3db
movq (%r14), %rax
movq %rsp, %r15
movl $0x1, %edx
movl $0x20, %ecx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movdqa (%r15), %xmm0
movdqu 0x3(%r15), %xmm1
pcmpeqb 0x3005df(%rip), %xmm1 # 0x59a9a0
pcmpeqb 0x3005e7(%rip), %xmm0 # 0x59a9b0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
sete %al
jmp 0x29a3dd
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29a402
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Assbin/AssbinLoader.cpp |
Assimp::AssbinImporter::ReadBinaryMaterial(Assimp::IOStream*, aiMaterial*) | void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat) {
if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIAL)
throw DeadlyImportError("Magic chunk identifiers are wrong!");
/*uint32_t size =*/ Read<uint32_t>(stream);
mat->mNumAllocated = mat->mNumProperties = Read<unsigned int>(stream);
if (mat->mNumProperties)
{
if (mat->mProperties)
{
delete[] mat->mProperties;
}
mat->mProperties = new aiMaterialProperty*[mat->mNumProperties];
for (unsigned int i = 0; i < mat->mNumProperties;++i) {
mat->mProperties[i] = new aiMaterialProperty();
ReadBinaryMaterialProperty( stream, mat->mProperties[i]);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x29ca14
cmpl $0x123d, %eax # imm = 0x123D
jne 0x29b5c2
movq %r14, %rdi
callq 0x29ca14
movq %r14, %rdi
callq 0x29ca14
movl %eax, 0x8(%rbx)
movl %eax, 0xc(%rbx)
testl %eax, %eax
je 0x29b5b5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29b539
callq 0x1a5610
movl 0x8(%rbx), %ebp
jmp 0x29b53b
movl %eax, %ebp
movl %ebp, %edi
shlq $0x3, %rdi
callq 0x1a57a0
movq %rax, (%rbx)
testl %ebp, %ebp
je 0x29b5b5
xorl %r12d, %r12d
movl $0x420, %edi # imm = 0x420
callq 0x1a5230
movq %rax, %r15
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
leaq 0x5(%rax), %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
movaps 0x2f67ef(%rip), %xmm0 # 0x591d70
movups %xmm0, 0x404(%r15)
movq $0x0, 0x418(%r15)
movq (%rbx), %rax
movq %r15, (%rax,%r12,8)
movq (%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rsi
callq 0x29b380
incq %r12
movl 0x8(%rbx), %eax
cmpq %rax, %r12
jb 0x29b550
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2ff43b(%rip), %rsi # 0x59aa1a
leaq 0x2ff456(%rip), %rdx # 0x59aa3c
movq %rsp, %rdi
callq 0x209290
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x442135(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x442101(%rip), %rsi # 0x6dd710
movq 0x51094a(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x29b637
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x29b641
jmp 0x29b649
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Assbin/AssbinLoader.cpp |
Assimp::AssbinImporter::ReadBinaryAnim(Assimp::IOStream*, aiAnimation*) | void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim ) {
if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIANIMATION)
throw DeadlyImportError("Magic chunk identifiers are wrong!");
/*uint32_t size =*/ Read<uint32_t>(stream);
anim->mName = Read<aiString> (stream);
anim->mDuration = Read<double> (stream);
anim->mTicksPerSecond = Read<double> (stream);
anim->mNumChannels = Read<unsigned int>(stream);
if (anim->mNumChannels) {
anim->mChannels = new aiNodeAnim*[ anim->mNumChannels ];
for (unsigned int a = 0; a < anim->mNumChannels;++a) {
anim->mChannels[a] = new aiNodeAnim();
ReadBinaryNodeAnim(stream,anim->mChannels[a]);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x29ca14
cmpl $0x123b, %eax # imm = 0x123B
jne 0x29ba2e
movq %r14, %rdi
callq 0x29ca14
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x29a4dc
cmpq %rbx, %r12
je 0x29b950
leaq 0x4(%rsp), %rsi
movl -0x4(%rsi), %r12d
movl %r12d, (%rbx)
leaq 0x4(%rbx), %rdi
movq %r12, %rdx
callq 0x1a5110
movb $0x0, 0x4(%rbx,%r12)
movq %r14, %rdi
callq 0x29cadc
movsd %xmm0, 0x408(%rbx)
movq %r14, %rdi
callq 0x29cadc
movsd %xmm0, 0x410(%rbx)
movq %r14, %rdi
callq 0x29ca14
movl %eax, 0x418(%rbx)
testl %eax, %eax
je 0x29ba1c
movl %eax, %edi
shlq $0x3, %rdi
callq 0x1a57a0
movq %rax, 0x420(%rbx)
xorl %r13d, %r13d
xorl %ebp, %ebp
movl $0x438, %edi # imm = 0x438
callq 0x1a5230
movq %rax, %r12
movl %r13d, (%rax)
movb $0x0, 0x4(%rax)
leaq 0x5(%rax), %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
movq $0x0, 0x418(%r12)
movl %r13d, 0x420(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x404(%r12)
movups %xmm0, 0x428(%r12)
movq 0x420(%rbx), %rax
movq %r12, (%rax,%rbp,8)
movq 0x420(%rbx), %rax
movq (%rax,%rbp,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x29b652
incq %rbp
movl 0x418(%rbx), %eax
cmpq %rax, %rbp
jb 0x29b99d
addq $0x408, %rsp # imm = 0x408
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 0x2fefcf(%rip), %rsi # 0x59aa1a
leaq 0x2fefea(%rip), %rdx # 0x59aa3c
movq %rsp, %rdi
callq 0x209290
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x441cc9(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x441c95(%rip), %rsi # 0x6dd710
movq 0x5104de(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x29baa3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x29baad
jmp 0x29bab5
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Assbin/AssbinLoader.cpp |
Assimp::AssbinImporter::ReadBinaryCamera(Assimp::IOStream*, aiCamera*) | void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam ) {
if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AICAMERA)
throw DeadlyImportError("Magic chunk identifiers are wrong!");
/*uint32_t size =*/ Read<uint32_t>(stream);
cam->mName = Read<aiString>(stream);
cam->mPosition = Read<aiVector3D>(stream);
cam->mLookAt = Read<aiVector3D>(stream);
cam->mUp = Read<aiVector3D>(stream);
cam->mHorizontalFOV = Read<float>(stream);
cam->mClipPlaneNear = Read<float>(stream);
cam->mClipPlaneFar = Read<float>(stream);
cam->mAspect = Read<float>(stream);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x29ca14
cmpl $0x1234, %eax # imm = 0x1234
jne 0x29bf5b
movq %r14, %rdi
callq 0x29ca14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x29a4dc
cmpq %rbx, %r15
je 0x29be5f
leaq 0x14(%rsp), %rsi
movl -0x4(%rsi), %r15d
movl %r15d, (%rbx)
leaq 0x4(%rbx), %rdi
movq %r15, %rdx
callq 0x1a5110
movb $0x0, 0x4(%rbx,%r15)
movq %r14, %rdi
callq 0x29c94a
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
movlps %xmm1, 0x404(%rbx)
movss %xmm0, 0x40c(%rbx)
movq %r14, %rdi
callq 0x29c94a
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
movlps %xmm1, 0x41c(%rbx)
movss %xmm0, 0x424(%rbx)
movq %r14, %rdi
callq 0x29c94a
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
movlps %xmm1, 0x410(%rbx)
movss %xmm0, 0x418(%rbx)
movq %r14, %rdi
callq 0x29c94a
movss %xmm0, 0x428(%rbx)
movq %r14, %rdi
callq 0x29c94a
movss %xmm0, 0x42c(%rbx)
movq %r14, %rdi
callq 0x29c94a
movss %xmm0, 0x430(%rbx)
movq %r14, %rdi
callq 0x29c94a
movss %xmm0, 0x434(%rbx)
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2feaa2(%rip), %rsi # 0x59aa1a
leaq 0x2feabd(%rip), %rdx # 0x59aa3c
leaq 0x10(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x441798(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x441764(%rip), %rsi # 0x6dd710
movq 0x50ffad(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x29bfd5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x29bfdf
jmp 0x29bfe7
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Assbin/AssbinLoader.cpp |
float Read<float>(Assimp::IOStream*) | T Read(IOStream * stream) {
T t;
size_t res = stream->Read( &t, sizeof(T), 1 );
if(res != 1)
throw DeadlyImportError("Unexpected EOF");
return t;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
movl $0x1, %ecx
callq *0x10(%rax)
cmpq $0x1, %rax
jne 0x29c980
movss 0x4(%rsp), %xmm0
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 0x306012(%rip), %rsi # 0x5a29af
leaq 0x306019(%rip), %rdx # 0x5a29bd
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x440d73(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x440d3f(%rip), %rsi # 0x6dd710
movq 0x50f588(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x29c9fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x29ca04
jmp 0x29ca0c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Assbin/AssbinLoader.cpp |
int Read<int>(Assimp::IOStream*) | T Read(IOStream * stream) {
T t;
size_t res = stream->Read( &t, sizeof(T), 1 );
if(res != 1)
throw DeadlyImportError("Unexpected EOF");
return t;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
movl $0x1, %ecx
callq *0x10(%rax)
cmpq $0x1, %rax
jne 0x29cd68
movl 0x4(%rsp), %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 0x305c2a(%rip), %rsi # 0x5a29af
leaq 0x305c31(%rip), %rdx # 0x5a29bd
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x44098b(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x440957(%rip), %rsi # 0x6dd710
movq 0x50f1a0(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x29cde2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x29cdec
jmp 0x29cdf4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Assbin/AssbinLoader.cpp |
void ReadArray<aiVector3t<float>>(Assimp::IOStream*, aiVector3t<float>*, unsigned int) | void ReadArray( IOStream *stream, T * out, unsigned int size) {
ai_assert( nullptr != stream );
ai_assert( nullptr != out );
for (unsigned int i=0; i<size; i++) {
out[i] = Read<T>(stream);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x29cffb
movq %rsi, %rbx
testq %rsi, %rsi
je 0x29d01a
testl %edx, %edx
je 0x29cfef
movq %rdi, %r14
movl %edx, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r15
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x29c94a
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm1, (%rsp)
movq %r14, %rdi
callq 0x29c94a
movaps (%rsp), %xmm1
movlps %xmm1, (%rbx,%r12)
movss %xmm0, 0x8(%rbx,%r12)
addq $0xc, %r12
cmpq %r12, %r15
jne 0x29cfaf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2f5947(%rip), %rdi # 0x592949
leaq 0x2fda9d(%rip), %rsi # 0x59aaa6
leaq 0x2fdc0d(%rip), %rcx # 0x59ac1d
movl $0xc6, %edx
callq 0x1a5270
leaq 0x2fdbed(%rip), %rdi # 0x59ac0e
leaq 0x2fda7e(%rip), %rsi # 0x59aaa6
leaq 0x2fdbee(%rip), %rcx # 0x59ac1d
movl $0xc7, %edx
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/assimp/code/Assbin/AssbinLoader.cpp |
Assimp::B3DImporter::ReadByte() | int B3DImporter::ReadByte(){
if( _pos<_buf.size() ) return _buf[_pos++];
Fail( "EOF" );
return 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x78(%rdi), %eax
movq 0x88(%rdi), %rdx
movq 0x80(%rdi), %rcx
subq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x29e666
leal 0x1(%rax), %edx
movl %edx, 0x78(%rdi)
movzbl (%rcx,%rax), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x304344(%rip), %rsi # 0x5a29ba
leaq 0x304340(%rip), %rdx # 0x5a29bd
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x209290
movq %rbx, %rsi
callq 0x29e5a2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x29e6ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/B3D/B3DImporter.cpp |
Assimp::B3DImporter::ReadQuat() | aiQuaternion B3DImporter::ReadQuat(){
// (aramis_acg) Fix to adapt the loader to changed quat orientation
float w=-ReadFloat();
float x=ReadFloat();
float y=ReadFloat();
float z=ReadFloat();
return aiQuaternion( w,x,y,z );
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x29e734
xorps 0x2bca74(%rip), %xmm0 # 0x55b2a0
movaps %xmm0, 0x20(%rsp)
movq %rbx, %rdi
callq 0x29e734
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x29e734
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x29e734
movaps 0x20(%rsp), %xmm2
unpcklps 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
movaps (%rsp), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
retq
| /hbina[P]fatuous/thirdparty/assimp/code/B3D/B3DImporter.cpp |
Assimp::B3DImporter::ReadBRUS() | void B3DImporter::ReadBRUS(){
int n_texs=ReadInt();
if( n_texs<0 || n_texs>8 ){
Fail( "Bad texture count" );
}
while( ChunkSize() ){
string name=ReadString();
aiVector3D color=ReadVec3();
float alpha=ReadFloat();
float shiny=ReadFloat();
/*int blend=**/ReadInt();
int fx=ReadInt();
std::unique_ptr<aiMaterial> mat(new aiMaterial);
// Name
aiString ainame( name );
mat->AddProperty( &ainame,AI_MATKEY_NAME );
// Diffuse color
mat->AddProperty( &color,1,AI_MATKEY_COLOR_DIFFUSE );
// Opacity
mat->AddProperty( &alpha,1,AI_MATKEY_OPACITY );
// Specular color
aiColor3D speccolor( shiny,shiny,shiny );
mat->AddProperty( &speccolor,1,AI_MATKEY_COLOR_SPECULAR );
// Specular power
float specpow=shiny*128;
mat->AddProperty( &specpow,1,AI_MATKEY_SHININESS );
// Double sided
if( fx & 0x10 ){
int i=1;
mat->AddProperty( &i,1,AI_MATKEY_TWOSIDED );
}
//Textures
for( int i=0;i<n_texs;++i ){
int texid=ReadInt();
if( texid<-1 || (texid>=0 && texid>=static_cast<int>(_textures.size())) ){
Fail( "Bad texture id" );
}
if( i==0 && texid>=0 ){
aiString texname( _textures[texid] );
mat->AddProperty( &texname,AI_MATKEY_TEXTURE_DIFFUSE(0) );
}
}
_materials.emplace_back( std::move(mat) );
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8d8, %rsp # imm = 0x8D8
movq %rdi, %rbx
callq 0x29e6b4
cmpl $0x8, %eax
ja 0x29ee73
movl %eax, %ebp
movq 0xa0(%rbx), %rax
movl -0x4(%rax), %eax
cmpl 0x78(%rbx), %eax
je 0x29ee2d
leaq 0xd4(%rsp), %r12
leaq 0xc8(%rbx), %rax
movq %rax, 0x68(%rsp)
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x29e86c
movq %rbx, %rdi
callq 0x29e734
movaps %xmm0, 0x30(%rsp)
movq %rbx, %rdi
callq 0x29e734
movaps %xmm0, 0xa0(%rsp)
movq %rbx, %rdi
callq 0x29e734
movaps 0x30(%rsp), %xmm1
unpcklps 0xa0(%rsp), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movlps %xmm1, 0x70(%rsp)
movss %xmm0, 0x78(%rsp)
movq %rbx, %rdi
callq 0x29e734
movss %xmm0, 0x20(%rsp)
movq %rbx, %rdi
callq 0x29e734
movss %xmm0, 0x30(%rsp)
movq %rbx, %rdi
callq 0x29e6b4
movq %rbx, %rdi
callq 0x29e6b4
movl %eax, %r14d
movl $0x10, %edi
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2466d0
movq %r15, 0x10(%rsp)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %r13
testl $0xfffffc00, %r13d # imm = 0xFFFFFC00
movl $0x3ff, %eax # imm = 0x3FF
cmovnel %eax, %r13d
movl %r13d, 0x4d4(%rsp)
leaq 0x4d8(%rsp), %rdi
movq %r13, %rdx
callq 0x1a5110
movb $0x0, 0x4d8(%rsp,%r13)
movq %r15, %rdi
leaq 0x4d4(%rsp), %rsi
leaq 0x2f0d10(%rip), %rdx # 0x58f939
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x246b54
movq 0x10(%rsp), %rdi
movl $0x1, (%rsp)
leaq 0x70(%rsp), %rsi
movl $0xc, %edx
leaq 0x2f0ccc(%rip), %rcx # 0x58f91c
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movq 0x10(%rsp), %rdi
movl $0x1, (%rsp)
leaq 0x20(%rsp), %rsi
movl $0x4, %edx
leaq 0x2f2310(%rip), %rcx # 0x590f88
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movss %xmm0, 0x28(%rsp)
movss %xmm0, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, (%rsp)
leaq 0x24(%rsp), %rsi
movl $0xc, %edx
leaq 0x2f9976(%rip), %rcx # 0x59862e
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movss 0x30(%rsp), %xmm0
mulss 0x2c1837(%rip), %xmm0 # 0x560508
movss %xmm0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, (%rsp)
leaq 0x1c(%rsp), %rsi
movl $0x4, %edx
leaq 0x2f21c3(%rip), %rcx # 0x590eb7
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
testb $0x10, %r14b
je 0x29ed3b
movl $0x1, 0xd0(%rsp)
movq 0x10(%rsp), %rdi
movl $0x4, (%rsp)
leaq 0xd0(%rsp), %rsi
movl $0x4, %edx
leaq 0x2fa1e2(%rip), %rcx # 0x598f12
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
testl %ebp, %ebp
je 0x29ede5
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x29e6b4
cmpl $-0x1, %eax
jl 0x29ee3f
testl %eax, %eax
js 0x29edd9
movq 0xb0(%rbx), %rcx
movq 0xb8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x5, %rdx
cmpl %edx, %eax
jge 0x29ee3f
testl %r15d, %r15d
jne 0x29edd9
movl %eax, %eax
shlq $0x5, %rax
movq 0x8(%rcx,%rax), %r14
testl $0xfffffc00, %r14d # imm = 0xFFFFFC00
movl $0x3ff, %edx # imm = 0x3FF
cmovnel %edx, %r14d
movl %r14d, 0xd0(%rsp)
movq (%rcx,%rax), %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x1a5110
movb $0x0, 0xd4(%rsp,%r14)
movq 0x10(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0x2f1d28(%rip), %rdx # 0x590af4
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x246b54
incl %r15d
cmpl %r15d, %ebp
jne 0x29ed46
movq 0x68(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a05e2
leaq 0x10(%rsp), %rdi
callq 0x2a0620
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x29ee1a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0xa0(%rbx), %rax
movl -0x4(%rax), %eax
cmpl 0x78(%rbx), %eax
jne 0x29eb49
addq $0x8d8, %rsp # imm = 0x8D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x90(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2fbf5c(%rip), %rsi # 0x59adae
leaq 0x2fbf63(%rip), %rdx # 0x59adbc
leaq 0x80(%rsp), %rdi
callq 0x209290
leaq 0x80(%rsp), %rsi
callq 0x29e5a2
leaq 0xc0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2fbf16(%rip), %rsi # 0x59ad9c
leaq 0x2fbf20(%rip), %rdx # 0x59adad
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
callq 0x209290
movq %rbx, %rsi
callq 0x29e5a2
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
cmpq %r14, %rdi
je 0x29ef39
movq 0xc0(%rsp), %rsi
jmp 0x29ef31
jmp 0x29ef10
jmp 0x29eee5
jmp 0x29eee5
jmp 0x29eee5
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x1a5190
jmp 0x29ef1d
jmp 0x29ef10
jmp 0x29ef10
jmp 0x29eee5
jmp 0x29ef10
movq %rax, %rbx
jmp 0x29ef1d
jmp 0x29ef10
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x29ef13
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x29ef13
jmp 0x29ef10
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2a0620
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x29ef39
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/B3D/B3DImporter.cpp |
Assimp::BVHLoader::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const | bool BVHLoader::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const
{
// check file extension
const std::string extension = GetExtension(pFile);
if( extension == "bvh")
return true;
if ((!extension.length() || cs) && pIOHandler) {
const char* tokens[] = {"HIERARCHY"};
return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x24818a
leaq 0x2f988a(%rip), %rsi # 0x59aeb0
movq %r15, %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x2a1649
cmpq $0x0, 0x18(%rsp)
je 0x2a164d
testq %r14, %r14
setne %al
testb %bpl, %al
jne 0x2a1652
xorl %ebx, %ebx
jmp 0x2a1683
movb $0x1, %bl
jmp 0x2a1683
testq %r14, %r14
je 0x2a1645
leaq 0x2f34b3(%rip), %rax # 0x594b0c
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movl $0x0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
movl $0xc8, %r8d
xorl %r9d, %r9d
callq 0x247ca8
movl %eax, %ebx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a169e
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 0x2a16c9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/BVH/BVHLoader.cpp |
Assimp::BVHLoader::ReadStructure(aiScene*) | void BVHLoader::ReadStructure( aiScene* pScene)
{
// first comes hierarchy
std::string header = GetNextToken();
if( header != "HIERARCHY")
ThrowException( "Expected header string \"HIERARCHY\".");
ReadHierarchy( pScene);
// then comes the motion data
std::string motion = GetNextToken();
if( motion != "MOTION")
ThrowException( "Expected beginning of motion data \"MOTION\".");
ReadMotion( pScene);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a297e
leaq 0x2f30b8(%rip), %rsi # 0x594b0c
movq %r15, %rdi
callq 0x1a60c0
testl %eax, %eax
jne 0x2a1ad1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a2ba0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2a297e
leaq 0x2f9470(%rip), %rsi # 0x59aeed
movq %rsp, %rdi
callq 0x1a60c0
testl %eax, %eax
jne 0x2a1afb
movq %rbx, %rdi
callq 0x2a2c70
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a1aac
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a1ac7
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2f93e8(%rip), %rsi # 0x59aec9
leaq 0x2f9404(%rip), %rdx # 0x59aeec
movq %rsp, %rdi
callq 0x209290
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2a2a78
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2f93e9(%rip), %rsi # 0x59aef4
leaq 0x2f940d(%rip), %rdx # 0x59af1f
leaq 0x20(%rsp), %rdi
callq 0x209290
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a2a78
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x2a1b5a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2a1b5a
jmp 0x2a1b57
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x2a1b68
jmp 0x2a1b7c
jmp 0x2a1b79
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a1b7c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2a1b7c
jmp 0x2a1b79
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a1b97
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/BVH/BVHLoader.cpp |
Assimp::BVHLoader::ReadNodeChannels(Assimp::BVHLoader::Node&) | void BVHLoader::ReadNodeChannels( BVHLoader::Node& pNode)
{
// number of channels. Use the float reader because we're lazy
float numChannelsFloat = GetNextTokenAsFloat();
unsigned int numChannels = (unsigned int) numChannelsFloat;
for( unsigned int a = 0; a < numChannels; a++)
{
std::string channelToken = GetNextToken();
if( channelToken == "Xposition")
pNode.mChannels.push_back( Channel_PositionX);
else if( channelToken == "Yposition")
pNode.mChannels.push_back( Channel_PositionY);
else if( channelToken == "Zposition")
pNode.mChannels.push_back( Channel_PositionZ);
else if( channelToken == "Xrotation")
pNode.mChannels.push_back( Channel_RotationX);
else if( channelToken == "Yrotation")
pNode.mChannels.push_back( Channel_RotationY);
else if( channelToken == "Zrotation")
pNode.mChannels.push_back( Channel_RotationZ);
else
ThrowException( format() << "Invalid channel specifier \"" << channelToken << "\"." );
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2a3dee
cvttss2si %xmm0, %rbp
testl %ebp, %ebp
je 0x2a39de
addq $0x8, %r14
movq %rsp, %r15
leaq 0x2f7734(%rip), %r12 # 0x59afdd
leaq 0x40(%rsp), %r13
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a297e
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a60c0
testl %eax, %eax
je 0x2a3954
movq %r15, %rdi
leaq 0x2f7711(%rip), %rsi # 0x59afe7
callq 0x1a60c0
testl %eax, %eax
je 0x2a3969
movq %r15, %rdi
leaq 0x2f7704(%rip), %rsi # 0x59aff1
callq 0x1a60c0
testl %eax, %eax
je 0x2a397e
movq %r15, %rdi
leaq 0x2f76f7(%rip), %rsi # 0x59affb
callq 0x1a60c0
testl %eax, %eax
je 0x2a3993
movq %r15, %rdi
leaq 0x2f76ea(%rip), %rsi # 0x59b005
callq 0x1a60c0
testl %eax, %eax
je 0x2a39a8
movq %r15, %rdi
leaq 0x2f76dd(%rip), %rsi # 0x59b00f
callq 0x1a60c0
testl %eax, %eax
jne 0x2a39f0
movl $0x5, 0x40(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a4452
jmp 0x2a39bb
movl $0x0, 0x40(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a4452
jmp 0x2a39bb
movl $0x1, 0x40(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a4452
jmp 0x2a39bb
movl $0x2, 0x40(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a4452
jmp 0x2a39bb
movl $0x3, 0x40(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a4452
jmp 0x2a39bb
movl $0x4, 0x40(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a4452
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2a39d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
decl %ebp
jne 0x2a38ae
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rdi
callq 0x1a6170
leaq 0x2f7618(%rip), %rsi # 0x59b019
leaq 0x40(%rsp), %rdi
movl $0x1b, %edx
callq 0x1a61e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x1a61e0
leaq 0x2f74f3(%rip), %rsi # 0x59af1d
leaq 0x40(%rsp), %rdi
movl $0x2, %edx
callq 0x1a61e0
leaq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1a5690
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a2a78
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a3a78
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2a3a78
movq %rax, %rbx
movq 0x508511(%rip), %rsi # 0x7abf90
leaq 0x40(%rsp), %rdi
callq 0x1a5d00
leaq 0xb0(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2a3aa7
jmp 0x2a3aa4
jmp 0x2a3aa4
jmp 0x2a3aa4
jmp 0x2a3aa4
jmp 0x2a3aa4
jmp 0x2a3aa4
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2a3ac2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/BVH/BVHLoader.cpp |
Assimp::BVHLoader::GetNextTokenAsFloat() | float BVHLoader::GetNextTokenAsFloat()
{
std::string token = GetNextToken();
if( token.empty())
ThrowException( "Unexpected end of file while trying to read a float");
// check if the float is valid by testing if the atof() function consumed every char of the token
const char* ctoken = token.c_str();
float result = 0.0f;
ctoken = fast_atoreal_move<float>( ctoken, result);
if( ctoken != token.c_str() + token.length())
ThrowException( format() << "Expected a floating point number, but found \"" << token << "\"." );
return result;
} | pushq %r14
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a297e
cmpq $0x0, 0x8(%r14)
je 0x2a3e72
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movl $0x1, %edx
callq 0x2470c9
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
addq %rdi, %rcx
cmpq %rcx, %rax
jne 0x2a3ea0
movss 0xc(%rsp), %xmm0
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x2a3e67
movq 0x20(%rsp), %rsi
incq %rsi
movss %xmm0, 0x8(%rsp)
callq 0x1a5190
movss 0x8(%rsp), %xmm0
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r14
retq
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2f7220(%rip), %rsi # 0x59b0a2
leaq 0x2f724c(%rip), %rdx # 0x59b0d5
leaq 0x50(%rsp), %rdi
callq 0x209290
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a2a78
leaq 0x50(%rsp), %rdi
callq 0x1a6170
leaq 0x2f7225(%rip), %rsi # 0x59b0d6
leaq 0x50(%rsp), %rdi
movl $0x2d, %edx
callq 0x1a61e0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x1a61e0
leaq 0x2f7042(%rip), %rsi # 0x59af1d
leaq 0x50(%rsp), %rdi
movl $0x2, %edx
callq 0x1a61e0
leaq 0x58(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1a5690
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a2a78
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a3f29
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2a3f29
movq %rax, %rbx
movq 0x508060(%rip), %rsi # 0x7abf90
leaq 0x50(%rsp), %rdi
callq 0x1a5d00
leaq 0xc0(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2a3f6c
jmp 0x2a3f69
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x2a3f6c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2a3f6c
jmp 0x2a3f69
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a3f87
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/BVH/BVHLoader.cpp |
Assimp::ColladaLoader::BuildMaterials(Assimp::ColladaParser&, aiScene*) | void ColladaLoader::BuildMaterials(ColladaParser& pParser, aiScene* /*pScene*/)
{
newMats.reserve(pParser.mMaterialLibrary.size());
for (ColladaParser::MaterialLibrary::const_iterator matIt = pParser.mMaterialLibrary.begin();
matIt != pParser.mMaterialLibrary.end(); ++matIt) {
const Collada::Material& material = matIt->second;
// a material is only a reference to an effect
ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect);
if (effIt == pParser.mEffectLibrary.end())
continue;
Collada::Effect& effect = effIt->second;
// create material
aiMaterial* mat = new aiMaterial;
aiString name(material.mName.empty() ? matIt->first : material.mName);
mat->AddProperty(&name, AI_MATKEY_NAME);
// store the material
mMaterialIndexByName[matIt->first] = newMats.size();
newMats.push_back(std::pair<Collada::Effect*, aiMaterial*>(&effect, mat));
}
// ScenePreprocessor generates a default material automatically if none is there.
// All further code here in this loader works well without a valid material so
// we can safely let it to ScenePreprocessor.
#if 0
if (newMats.size() == 0)
{
aiMaterial* mat = new aiMaterial;
aiString name(AI_DEFAULT_MATERIAL_NAME);
mat->AddProperty(&name, AI_MATKEY_NAME);
const int shadeMode = aiShadingMode_Phong;
mat->AddProperty<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
aiColor4D colAmbient(0.2, 0.2, 0.2, 1.0), colDiffuse(0.8, 0.8, 0.8, 1.0), colSpecular(0.5, 0.5, 0.5, 0.5);
mat->AddProperty(&colAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
mat->AddProperty(&colDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
mat->AddProperty(&colSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
const ai_real specExp = 5.0;
mat->AddProperty(&specExp, 1, AI_MATKEY_SHININESS);
}
#endif
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rsi, %rbx
movq %rdi, %r14
addq $0x128, %rdi # imm = 0x128
movq 0x170(%rsi), %rsi
movq %rdi, 0x8(%rsp)
callq 0x2ac586
movq 0x160(%rbx), %r12
leaq 0x150(%rbx), %rcx
movq %rcx, 0x28(%rsp)
cmpq %rcx, %r12
je 0x2a5b6a
movq %rbx, %rax
leaq 0x118(%rbx), %rcx
movq %rcx, 0x18(%rsp)
addq $0x120, %rax # imm = 0x120
movq %rax, 0x20(%rsp)
leaq 0xc8(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x60(%r12), %rsi
movq 0x18(%rsp), %rdi
callq 0x2af46a
cmpq 0x20(%rsp), %rax
je 0x2a5b54
movq %rax, %rbp
movl $0x10, %edi
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2466d0
leaq 0x20(%r12), %r13
leaq 0x40(%r12), %rax
addq $0x40, %rbp
xorl %ecx, %ecx
cmpq $0x0, 0x48(%r12)
cmoveq %r13, %rax
setne %cl
shll $0x5, %ecx
movq 0x8(%rax), %rbx
testl $0xfffffc00, %ebx # imm = 0xFFFFFC00
movl $0x3ff, %eax # imm = 0x3FF
cmovnel %eax, %ebx
movl %ebx, 0x44(%rsp)
movq 0x20(%rcx,%r12), %rsi
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x1a5110
movb $0x0, 0x48(%rsp,%rbx)
movq %r15, %rdi
leaq 0x44(%rsp), %rsi
leaq 0x2e9e4c(%rip), %rdx # 0x58f939
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x246b54
movq 0x130(%r14), %rbx
subq 0x128(%r14), %rbx
sarq $0x4, %rbx
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x2ad0ca
movq %rbx, (%rax)
movq %rbp, 0x30(%rsp)
movq %r15, 0x38(%rsp)
movq 0x130(%r14), %rsi
cmpq 0x138(%r14), %rsi
je 0x2a5b45
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x130(%r14)
jmp 0x2a5b54
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x2af806
movq %r12, %rdi
callq 0x1a60d0
movq %rax, %r12
cmpq 0x28(%rsp), %rax
jne 0x2a5a5f
addq $0x448, %rsp # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaLoader.cpp |
Assimp::ColladaLoader::FindNameForNode[abi:cxx11](Assimp::Collada::Node const*) | std::string ColladaLoader::FindNameForNode(const Collada::Node* pNode)
{
// If explicitly requested, just use the collada name.
if (useColladaName)
{
if (!pNode->mName.empty()) {
return pNode->mName;
}
else {
return format() << "$ColladaAutoName$_" << mNodeNameCounter++;
}
}
else
{
// Now setup the name of the assimp node. The collada name might not be
// unique, so we use the collada ID.
if (!pNode->mID.empty())
return pNode->mID;
else if (!pNode->mSID.empty())
return pNode->mSID;
else
{
// No need to worry. Unnamed nodes are no problem at all, except
// if cameras or lights need to be assigned to them.
return format() << "$ColladaAutoName$_" << mNodeNameCounter++;
}
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x1a2(%rsi)
jne 0x2a6aba
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x2a6ad0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rdx), %rsi
jmp 0x2a6b2f
movq 0x28(%rdx), %rax
testq %rax, %rax
je 0x2a6b1b
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x20(%rdx), %rsi
jmp 0x2a6b2f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1a6170
leaq 0x2f4f03(%rip), %rsi # 0x59b9e7
movl $0x12, %edx
movq %r15, %rdi
callq 0x1a61e0
movl 0x1a4(%r14), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x1a4(%r14)
leaq 0x8(%rsp), %rdi
callq 0x1a5850
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a5690
jmp 0x2a6b88
movq 0x48(%rdx), %rax
testq %rax, %rax
je 0x2a6b3f
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x40(%rdx), %rsi
addq %rsi, %rax
movq %rbx, %rdi
movq %rax, %rdx
callq 0x20ac60
jmp 0x2a6ba3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1a6170
leaq 0x2f4e94(%rip), %rsi # 0x59b9e7
movl $0x12, %edx
movq %r15, %rdi
callq 0x1a61e0
movl 0x1a4(%r14), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x1a4(%r14)
leaq 0x8(%rsp), %rdi
callq 0x1a5850
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a5690
movq 0x505401(%rip), %rsi # 0x7abf90
leaq 0x8(%rsp), %rdi
callq 0x1a5d00
leaq 0x78(%rsp), %rdi
callq 0x1a5ca0
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2a6bb9
jmp 0x2a6bb9
jmp 0x2a6bb9
movq %rax, %rbx
movq 0x5053cd(%rip), %rsi # 0x7abf90
leaq 0x8(%rsp), %rdi
callq 0x1a5d00
leaq 0x78(%rsp), %rdi
callq 0x1a5ca0
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaLoader.cpp |
Assimp::ColladaLoader::BuildMeshesForNode(Assimp::ColladaParser const&, Assimp::Collada::Node const*, aiNode*) | void ColladaLoader::BuildMeshesForNode(const ColladaParser& pParser, const Collada::Node* pNode, aiNode* pTarget) {
// accumulated mesh references by this node
std::vector<size_t> newMeshRefs;
newMeshRefs.reserve(pNode->mMeshes.size());
// add a mesh for each subgroup in each collada mesh
for (const Collada::MeshInstance& mid : pNode->mMeshes) {
const Collada::Mesh* srcMesh = nullptr;
const Collada::Controller* srcController = nullptr;
// find the referred mesh
ColladaParser::MeshLibrary::const_iterator srcMeshIt = pParser.mMeshLibrary.find(mid.mMeshOrController);
if (srcMeshIt == pParser.mMeshLibrary.end()) {
// if not found in the mesh-library, it might also be a controller referring to a mesh
ColladaParser::ControllerLibrary::const_iterator srcContrIt = pParser.mControllerLibrary.find(mid.mMeshOrController);
if (srcContrIt != pParser.mControllerLibrary.end()) {
srcController = &srcContrIt->second;
srcMeshIt = pParser.mMeshLibrary.find(srcController->mMeshId);
if (srcMeshIt != pParser.mMeshLibrary.end()) {
srcMesh = srcMeshIt->second;
}
}
if( nullptr == srcMesh) {
ASSIMP_LOG_WARN_F( "Collada: Unable to find geometry for ID \"", mid.mMeshOrController, "\". Skipping." );
continue;
}
}
else {
// ID found in the mesh library -> direct reference to an unskinned mesh
srcMesh = srcMeshIt->second;
}
// build a mesh for each of its subgroups
size_t vertexStart = 0, faceStart = 0;
for (size_t sm = 0; sm < srcMesh->mSubMeshes.size(); ++sm) {
const Collada::SubMesh& submesh = srcMesh->mSubMeshes[sm];
if (submesh.mNumFaces == 0) {
continue;
}
// find material assigned to this submesh
std::string meshMaterial;
std::map<std::string, Collada::SemanticMappingTable >::const_iterator meshMatIt = mid.mMaterials.find(submesh.mMaterial);
const Collada::SemanticMappingTable* table = nullptr;
if (meshMatIt != mid.mMaterials.end()) {
table = &meshMatIt->second;
meshMaterial = table->mMatName;
}
else {
ASSIMP_LOG_WARN_F("Collada: No material specified for subgroup <", submesh.mMaterial, "> in geometry <",
mid.mMeshOrController, ">.");
if (!mid.mMaterials.empty()) {
meshMaterial = mid.mMaterials.begin()->second.mMatName;
}
}
// OK ... here the *real* fun starts ... we have the vertex-input-to-effect-semantic-table
// given. The only mapping stuff which we do actually support is the UV channel.
std::map<std::string, size_t>::const_iterator matIt = mMaterialIndexByName.find(meshMaterial);
unsigned int matIdx = 0;
if (matIt != mMaterialIndexByName.end()) {
matIdx = static_cast<unsigned int>(matIt->second);
}
if (table && !table->mMap.empty()) {
std::pair<Collada::Effect*, aiMaterial*>& mat = newMats[matIdx];
// Iterate through all texture channels assigned to the effect and
// check whether we have mapping information for it.
ApplyVertexToEffectSemanticMapping(mat.first->mTexDiffuse, *table);
ApplyVertexToEffectSemanticMapping(mat.first->mTexAmbient, *table);
ApplyVertexToEffectSemanticMapping(mat.first->mTexSpecular, *table);
ApplyVertexToEffectSemanticMapping(mat.first->mTexEmissive, *table);
ApplyVertexToEffectSemanticMapping(mat.first->mTexTransparent, *table);
ApplyVertexToEffectSemanticMapping(mat.first->mTexBump, *table);
}
// built lookup index of the Mesh-Submesh-Material combination
ColladaMeshIndex index(mid.mMeshOrController, sm, meshMaterial);
// if we already have the mesh at the library, just add its index to the node's array
std::map<ColladaMeshIndex, size_t>::const_iterator dstMeshIt = mMeshIndexByID.find(index);
if (dstMeshIt != mMeshIndexByID.end()) {
newMeshRefs.push_back(dstMeshIt->second);
}
else {
// else we have to add the mesh to the collection and store its newly assigned index at the node
aiMesh* dstMesh = CreateMesh(pParser, srcMesh, submesh, srcController, vertexStart, faceStart);
// store the mesh, and store its new index in the node
newMeshRefs.push_back(mMeshes.size());
mMeshIndexByID[index] = mMeshes.size();
mMeshes.push_back(dstMesh);
vertexStart += dstMesh->mNumVertices; faceStart += submesh.mNumFaces;
// assign the material index
dstMesh->mMaterialIndex = matIdx;
if (dstMesh->mName.length == 0) {
dstMesh->mName = mid.mMeshOrController;
}
}
}
}
// now place all mesh references we gathered in the target node
pTarget->mNumMeshes = static_cast<unsigned int>(newMeshRefs.size());
if (newMeshRefs.size()) {
struct UIntTypeConverter {
unsigned int operator()(const size_t& v) const {
return static_cast<unsigned int>(v);
}
};
pTarget->mMeshes = new unsigned int[pTarget->mNumMeshes];
std::transform(newMeshRefs.begin(), newMeshRefs.end(), pTarget->mMeshes, UIntTypeConverter());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rcx, 0x60(%rsp)
movq %rdx, %rbx
movq %rsi, 0x78(%rsp)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0xa0(%rdx), %rsi
subq 0x98(%rdx), %rsi
movq %rdi, %r14
sarq $0x4, %rsi
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rsi
movq %rax, %rdi
callq 0x2ac8aa
movq 0x98(%rbx), %r13
movq 0xa0(%rbx), %rax
movq %rax, 0xe0(%rsp)
cmpq %rax, %r13
je 0x2a74cb
movq 0x78(%rsp), %rax
leaq 0x88(%rax), %rcx
movq %rcx, 0x70(%rsp)
leaq 0x90(%rax), %rcx
movq %rcx, 0x68(%rsp)
leaq 0x1d8(%rax), %rcx
movq %rcx, 0xd8(%rsp)
addq $0x1e0, %rax # imm = 0x1E0
movq %rax, 0xd0(%rsp)
leaq 0xc8(%r14), %rax
movq %rax, 0x100(%rsp)
leaq 0xd0(%r14), %rax
movq %rax, 0xf8(%rsp)
leaq 0x98(%r14), %rax
movq %rax, 0x98(%rsp)
leaq 0xa0(%r14), %rax
movq %rax, 0xf0(%rsp)
leaq 0xf8(%r14), %rax
movq %rax, 0xe8(%rsp)
movq %r14, 0x88(%rsp)
movq 0x70(%rsp), %rdi
movq %r13, %rsi
callq 0x2ad6c0
cmpq 0x68(%rsp), %rax
je 0x2a73c6
movq 0x40(%rax), %rsi
movq $0x0, 0x80(%rsp)
movq 0x288(%rsi), %rbx
movq 0x290(%rsi), %rax
cmpq %rbx, %rax
je 0x2a74b9
leaq 0x20(%r13), %rcx
movq %rcx, 0x110(%rsp)
leaq 0x28(%r13), %rcx
movq %rcx, 0x108(%rsp)
xorl %r12d, %r12d
xorl %r15d, %r15d
movq $0x0, 0x38(%rsp)
movq $0x0, 0x90(%rsp)
movq %rsi, 0xa0(%rsp)
cmpq $0x0, 0x20(%rbx,%r12)
je 0x2a7399
movq %r13, %r14
leaq (%rbx,%r12), %rsi
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
movq 0x110(%rsp), %rdi
movq %rsi, 0xa8(%rsp)
callq 0x2ad7d4
movq %rax, %r13
cmpq 0x108(%rsp), %rax
je 0x2a6fa3
addq $0x40, %r13
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x1a64a0
jmp 0x2a7094
callq 0x241234
movq %rax, %r13
leaq 0x120(%rsp), %rbp
movq %rbp, %rdi
leaq 0x2f443b(%rip), %rsi # 0x59b3f8
callq 0x260cac
movq (%rbx,%r12), %rsi
movq 0x8(%rbx,%r12), %rdx
movq %rbp, %rdi
callq 0x1a61e0
movl $0xf, %edx
movq %rbp, %rdi
leaq 0x2f4444(%rip), %rsi # 0x59b426
callq 0x1a61e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbp, %rdi
callq 0x1a61e0
movl $0x2, %edx
movq %rbp, %rdi
leaq 0x2f085a(%rip), %rsi # 0x59785f
callq 0x1a61e0
leaq 0xb0(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x1a5690
movq 0xb0(%rsp), %rsi
movq %r13, %rdi
callq 0x241182
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
movq %r14, %rbx
je 0x2a7057
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x120(%rsp), %rdi
movq 0x504f2a(%rip), %rsi # 0x7abf90
callq 0x1a5d00
leaq 0x190(%rsp), %rdi
callq 0x1a5ca0
cmpq $0x0, 0x48(%rbx)
je 0x2a7091
movq 0x38(%rbx), %rsi
addq $0x40, %rsi
leaq 0x18(%rsp), %rdi
callq 0x1a64a0
xorl %r13d, %r13d
movq 0x100(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2ad85e
cmpq 0xf8(%rsp), %rax
je 0x2a70b9
movl 0x40(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x2a70c1
movl $0x0, 0x14(%rsp)
testq %r13, %r13
je 0x2a7164
cmpq $0x0, 0x48(%r13)
je 0x2a7164
movl 0x14(%rsp), %ebx
movq 0x88(%rsp), %rax
movq 0x128(%rax), %rbp
shlq $0x4, %rbx
movq (%rbp,%rbx), %rsi
movl $0x148, %eax # imm = 0x148
addq %rax, %rsi
movq %r13, %rdx
callq 0x2a7f0c
addq %rbx, %rbp
movq (%rbp), %rsi
movl $0xd8, %eax
addq %rax, %rsi
movq %r13, %rdx
callq 0x2a7f0c
movq (%rbp), %rsi
movl $0x1b8, %eax # imm = 0x1B8
addq %rax, %rsi
movq %r13, %rdx
callq 0x2a7f0c
movq (%rbp), %rsi
addq $0x68, %rsi
movq %r13, %rdx
callq 0x2a7f0c
movq (%rbp), %rsi
movl $0x228, %eax # imm = 0x228
addq %rax, %rsi
movq %r13, %rdx
callq 0x2a7f0c
movq (%rbp), %rsi
movl $0x298, %eax # imm = 0x298
addq %rax, %rsi
movq %r13, %rdx
callq 0x2a7f0c
leaq 0x120(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %r13
movq %r14, %rsi
movq %r15, %rdx
leaq 0x18(%rsp), %rcx
callq 0x2ac946
movq 0x98(%rsp), %rdi
movq %rbx, %rsi
callq 0x2ad8e8
cmpq 0xf0(%rsp), %rax
je 0x2a71c1
addq $0x68, %rax
movq 0x48(%rsp), %rsi
cmpq 0x50(%rsp), %rsi
je 0x2a7285
movq (%rax), %rax
movq %rax, (%rsi)
addq $0x8, 0x48(%rsp)
jmp 0x2a731d
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x88(%rsp), %rbp
movq %rbp, %rdi
movq 0x78(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
movq 0x80(%rsp), %r8
movq 0x90(%rsp), %r9
callq 0x2a7f58
movq %rax, 0xb0(%rsp)
movq 0x100(%rbp), %rax
subq 0xf8(%rbp), %rax
sarq $0x3, %rax
movq %rax, 0x118(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x2adad8
movq 0xf8(%rbp), %r13
movq 0x100(%rbp), %rbx
movq 0x98(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x2ac9ba
subq %r13, %rbx
sarq $0x3, %rbx
movq %rbx, (%rax)
movq 0x100(%rbp), %rsi
cmpq 0x108(%rbp), %rsi
je 0x2a7297
movq 0xb0(%rsp), %r13
movq %r13, (%rsi)
addq $0x8, 0x100(%rbp)
jmp 0x2a72b4
leaq 0x40(%rsp), %rdi
movq %rax, %rdx
callq 0x2ad9b8
jmp 0x2a731d
movq 0xe8(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x250da2
movq 0xb0(%rsp), %r13
movl 0x4(%r13), %ebp
movq 0x38(%rsp), %rax
movq 0xa8(%rsp), %rcx
addq 0x20(%rcx), %rax
movq %rax, 0x38(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xe8(%r13)
cmpl $0x0, 0xec(%r13)
jne 0x2a7312
movq 0x8(%r14), %rbx
cmpq $0x3ff, %rbx # imm = 0x3FF
ja 0x2a7312
movl %ebx, 0xec(%r13)
leaq 0xf0(%r13), %rdi
movq (%r14), %rsi
movq %rbx, %rdx
callq 0x1a5110
movb $0x0, 0xf0(%r13,%rbx)
addq %rbp, 0x90(%rsp)
movq %r14, %r13
movq 0x148(%rsp), %rdi
leaq 0x158(%rsp), %rax
cmpq %rax, %rdi
je 0x2a7342
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x120(%rsp), %rdi
leaq 0x130(%rsp), %rax
cmpq %rax, %rdi
je 0x2a7367
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2a7383
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0xa0(%rsp), %rsi
movq 0x288(%rsi), %rbx
movq 0x290(%rsi), %rax
incq %r15
movq %rax, %rcx
subq %rbx, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
addq $0x28, %r12
cmpq %rcx, %r15
jb 0x2a6f40
jmp 0x2a74b9
movq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0x2ad74a
movq %rax, %rbx
cmpq 0xd0(%rsp), %rax
je 0x2a7412
leaq 0x48(%rbx), %rsi
movq 0x70(%rsp), %rdi
callq 0x2ad6c0
cmpq 0x68(%rsp), %rax
je 0x2a7412
movq 0x40(%rax), %rsi
testq %rsi, %rsi
je 0x2a7412
addq $0x40, %rbx
movq %rbx, 0x80(%rsp)
jmp 0x2a6eee
callq 0x241234
movq %rax, %rbx
leaq 0x120(%rsp), %r14
movq %r14, %rdi
leaq 0x2f3fa2(%rip), %rsi # 0x59b3ce
callq 0x24923e
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x1a61e0
movl $0xc, %edx
leaq 0x120(%rsp), %rdi
leaq 0x2f3f13(%rip), %rsi # 0x59b368
callq 0x1a61e0
leaq 0x18(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x1a5690
movq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x241182
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
leaq 0x120(%rsp), %rbx
je 0x2a749d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
movq 0x504ae9(%rip), %rsi # 0x7abf90
callq 0x1a5d00
leaq 0x190(%rsp), %rdi
callq 0x1a5ca0
addq $0x50, %r13
cmpq 0xe0(%rsp), %r13
jne 0x2a6ec6
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %r14
movq %r14, %rcx
subq %rbx, %rcx
shrq $0x3, %rcx
movq %r14, %rax
movq 0x60(%rsp), %rdx
movl %ecx, 0x460(%rdx)
subq %rbx, %rax
je 0x2a7527
shrq %rax
movabsq $0x3fffffffc, %rdi # imm = 0x3FFFFFFFC
andq %rax, %rdi
callq 0x1a57a0
movq 0x60(%rsp), %rcx
movq %rax, 0x468(%rcx)
movq %rbx, %rcx
movl (%rcx), %edx
movl %edx, (%rax)
addq $0x8, %rcx
addq $0x4, %rax
cmpq %r14, %rcx
jne 0x2a7516
testq %rbx, %rbx
je 0x2a753c
movq 0x50(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x1a5190
addq $0x298, %rsp # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a75a0
jmp 0x2a75a0
jmp 0x2a75a0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2a757a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2a757a
jmp 0x2a75a0
movq %rax, %rbx
movq 0x504a0f(%rip), %rsi # 0x7abf90
leaq 0x120(%rsp), %rdi
callq 0x1a5d00
leaq 0x190(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2a763b
movq %rax, %rbx
jmp 0x2a763b
jmp 0x2a75dc
jmp 0x2a761c
jmp 0x2a761c
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
cmpq %rax, %rdi
je 0x2a75f9
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2a75f9
jmp 0x2a75dc
jmp 0x2a75dc
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x2aca4e
jmp 0x2a761f
jmp 0x2a761c
jmp 0x2a761c
jmp 0x2a761c
jmp 0x2a761c
movq %rax, %rbx
movq 0x504990(%rip), %rsi # 0x7abf90
leaq 0x120(%rsp), %rdi
callq 0x1a5d00
leaq 0x190(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2a761f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2a763b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2a7652
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaLoader.cpp |
Assimp::ColladaLoader::FindNode(Assimp::Collada::Node const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const Collada::Node* ColladaLoader::FindNode(const Collada::Node* pNode, const std::string& pName) const
{
if (pNode->mName == pName || pNode->mID == pName)
return pNode;
for (size_t a = 0; a < pNode->mChildren.size(); ++a)
{
const Collada::Node* node = FindNode(pNode->mChildren[a], pName);
if (node)
return node;
}
return NULL;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rdx
movq 0x8(%r14), %r12
cmpq %r12, %rdx
jne 0x2a7e99
testq %rdx, %rdx
je 0x2a7ef9
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x1a5c20
testl %eax, %eax
je 0x2a7ef9
cmpq %r12, 0x28(%rbx)
jne 0x2a7eb7
testq %r12, %r12
je 0x2a7ef9
movq (%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r12, %rdx
callq 0x1a5c20
testl %eax, %eax
je 0x2a7ef9
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %r13
subq %r12, %r13
je 0x2a7ef2
sarq $0x3, %r13
cmpq $0x1, %r13
adcq $0x0, %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x2a7e64
testq %rax, %rax
jne 0x2a7ef6
incq %rbp
cmpq %rbp, %r13
jne 0x2a7ed4
jmp 0x2a7ef9
xorl %ebx, %ebx
jmp 0x2a7ef9
movq %rax, %rbx
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/Collada/ColladaLoader.cpp |
Assimp::ColladaParser::TestTextContent() | const char* ColladaParser::TestTextContent()
{
// present node should be the beginning of an element
if (mReader->getNodeType() != irr::io::EXN_ELEMENT || mReader->isEmptyElement())
return NULL;
// read contents of the element
if (!mReader->read())
return NULL;
if (mReader->getNodeType() != irr::io::EXN_TEXT && mReader->getNodeType() != irr::io::EXN_CDATA)
return NULL;
// skip leading whitespace
const char* text = mReader->getNodeData();
SkipSpacesAndLineEnd(&text);
return text;
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x2b4d17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
jne 0x2b4d17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x2b4d17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x3, %eax
je 0x2b4cef
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x5, %eax
jne 0x2b4d17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movabsq $0x100002600, %rcx # imm = 0x100002600
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0x2b4d19
btq %rdx, %rcx
jae 0x2b4d19
incq %rax
jmp 0x2b4d03
xorl %eax, %eax
popq %rbx
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaParser.cpp |
Assimp::ColladaParser::ReadSource() | void ColladaParser::ReadSource()
{
int indexID = GetAttribute("id");
std::string sourceID = mReader->getAttributeValue(indexID);
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("float_array") || IsElement("IDREF_array") || IsElement("Name_array"))
{
ReadDataArray();
}
else if (IsElement("technique_common"))
{
// I don't care for your profiles
}
else if (IsElement("accessor"))
{
ReadAccessor(sourceID);
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "source") == 0)
{
// end of <source> - we're done
break;
}
else if (strcmp(mReader->getNodeName(), "technique_common") == 0)
{
// end of another meaningless element - read over it
}
else
{
// everything else should be punished
ThrowException("Expected end of <source> element.");
}
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x2abc15(%rip), %rsi # 0x561635
callq 0x2b5ca8
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x30(%rcx)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x23ca1c
leaq 0x2e6c54(%rip), %r15 # 0x59c69e
leaq 0x2e6c59(%rip), %r12 # 0x59c6aa
leaq 0x2e6c5e(%rip), %r13 # 0x59c6b6
leaq 0x2e6c0e(%rip), %rbp # 0x59c66d
leaq 0x2e3e20(%rip), %r14 # 0x599886
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x2b5bed
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
cmpl $0x1, %eax
jne 0x2b5b8b
callq *%rcx
cmpl $0x1, %eax
jne 0x2b5c17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2b5bce
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x2b5c17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2b5bce
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x2b5c17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %r13, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2b5bce
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x2b5c17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2b5a66
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x2b5c17
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
leaq 0x2e6b4c(%rip), %rsi # 0x59c6c1
callq 0x1a5f30
testl %eax, %eax
je 0x2b5bdb
movq %rbx, %rdi
callq 0x2b13ae
jmp 0x2b5a66
callq *%rcx
cmpl $0x2, %eax
jne 0x2b5a66
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2b5bed
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %rbp, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2b5a66
jmp 0x2b5c36
movq %rbx, %rdi
callq 0x2ba816
jmp 0x2b5a66
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2bacd2
jmp 0x2b5a66
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b5c08
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e762e(%rip), %rdi # 0x59d24c
leaq 0x2e7656(%rip), %rsi # 0x59d27b
leaq 0x2e76c7(%rip), %rcx # 0x59d2f3
movl $0x178, %edx # imm = 0x178
callq 0x1a5270
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2e6a84(%rip), %rsi # 0x59c6ca
leaq 0x2e6a9e(%rip), %rdx # 0x59c6eb
leaq 0x8(%rsp), %rdi
callq 0x209290
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b08dc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b5c85
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2b5c85
jmp 0x2b5c82
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b5ca0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaParser.cpp |
Assimp::ColladaParser::ReadAnimationSampler(Assimp::Collada::AnimationChannel&) | void ColladaParser::ReadAnimationSampler(Collada::AnimationChannel& pChannel)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
if (IsElement("input"))
{
int indexSemantic = GetAttribute("semantic");
const char* semantic = mReader->getAttributeValue(indexSemantic);
int indexSource = GetAttribute("source");
const char* source = mReader->getAttributeValue(indexSource);
if (source[0] != '#')
ThrowException("Unsupported URL format");
source++;
if (strcmp(semantic, "INPUT") == 0)
pChannel.mSourceTimes = source;
else if (strcmp(semantic, "OUTPUT") == 0)
pChannel.mSourceValues = source;
else if (strcmp(semantic, "IN_TANGENT") == 0)
pChannel.mInTanValues = source;
else if (strcmp(semantic, "OUT_TANGENT") == 0)
pChannel.mOutTanValues = source;
else if (strcmp(semantic, "INTERPOLATION") == 0)
pChannel.mInterpolationValues = source;
if (!mReader->isEmptyElement())
SkipElement();
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "sampler") != 0)
ThrowException("Expected end of <sampler> element.");
break;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x2b5fc4
leaq 0xa0(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0xa8(%r14), %rax
movq %rax, 0x20(%rsp)
leaq 0x80(%r14), %rax
movq %rax, 0x38(%rsp)
leaq 0x88(%r14), %rax
movq %rax, 0x30(%rsp)
leaq 0x60(%r14), %rax
movq %rax, 0x48(%rsp)
leaq 0x68(%r14), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%r14), %rax
movq %rax, 0x58(%rsp)
leaq 0x48(%r14), %rax
movq %rax, 0x50(%rsp)
leaq 0x20(%r14), %rax
movq %rax, 0x60(%rsp)
addq $0x28, %r14
leaq 0x2d8bc5(%rip), %r15 # 0x58ea01
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %ebp
jne 0x2b5f8e
cmpl $0x1, %eax
jne 0x2b5fd3
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a5f30
testl %eax, %eax
jne 0x2b5f84
movq %rbx, %rdi
leaq 0x2e7080(%rip), %rsi # 0x59cf0b
callq 0x2b5ca8
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x30(%rcx)
movq %rax, %r13
movq %rbx, %rdi
leaq 0x2e39dd(%rip), %rsi # 0x599886
callq 0x2b5ca8
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x30(%rcx)
cmpb $0x23, (%rax)
jne 0x2b5ff2
movq %rax, %r12
movq %r13, %rdi
leaq 0x2e602c(%rip), %rsi # 0x59befc
callq 0x1a5f30
movq %r14, %rcx
movq 0x60(%rsp), %rbp
testl %eax, %eax
je 0x2b5f55
movq %r13, %rdi
leaq 0x2e6017(%rip), %rsi # 0x59bf02
callq 0x1a5f30
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rbp
testl %eax, %eax
je 0x2b5f55
movq %r13, %rdi
leaq 0x2e6001(%rip), %rsi # 0x59bf09
callq 0x1a5f30
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rbp
testl %eax, %eax
je 0x2b5f55
movq %r13, %rdi
leaq 0x2e5fef(%rip), %rsi # 0x59bf14
callq 0x1a5f30
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rbp
testl %eax, %eax
je 0x2b5f55
movq %r13, %rdi
leaq 0x2e5fde(%rip), %rsi # 0x59bf20
callq 0x1a5f30
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rbp
testl %eax, %eax
jne 0x2b5f76
incq %r12
movq (%rcx), %r13
movq %r12, %rdi
callq 0x1a56a0
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x1a5830
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
jne 0x2b5f93
movq %rbx, %rdi
callq 0x2b13ae
jmp 0x2b5f93
cmpl $0x2, %eax
je 0x2b5fa7
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x2b5e3c
jmp 0x2b5fc4
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x2e5f00(%rip), %rsi # 0x59beb8
movq %rax, %rdi
callq 0x1a5f30
testl %eax, %eax
jne 0x2b601c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e7272(%rip), %rdi # 0x59d24c
leaq 0x2e729a(%rip), %rsi # 0x59d27b
leaq 0x2e730b(%rip), %rcx # 0x59d2f3
movl $0x178, %edx # imm = 0x178
callq 0x1a5270
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2e5ee3(%rip), %rsi # 0x59bee5
leaq 0x2e5ef2(%rip), %rdx # 0x59befb
movq %rsp, %rdi
callq 0x209290
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2b08dc
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2e5f02(%rip), %rsi # 0x59bf2e
leaq 0x2e5f1d(%rip), %rdx # 0x59bf50
movq %rsp, %rdi
callq 0x209290
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2b08dc
jmp 0x2b604a
jmp 0x2b6065
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x2b6068
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2b6068
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaParser.cpp |
Assimp::ColladaParser::ReadControllerWeights(Assimp::Collada::Controller&) | void ColladaParser::ReadControllerWeights(Collada::Controller& pController)
{
// read vertex count from attributes and resize the array accordingly
int indexCount = GetAttribute("count");
size_t vertexCount = (size_t)mReader->getAttributeValueAsInt(indexCount);
pController.mWeightCounts.resize(vertexCount);
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT)
{
// Input channels for weight data. Two possible semantics: "JOINT" and "WEIGHT"
if (IsElement("input") && vertexCount > 0)
{
InputChannel channel;
int indexSemantic = GetAttribute("semantic");
const char* attrSemantic = mReader->getAttributeValue(indexSemantic);
int indexSource = GetAttribute("source");
const char* attrSource = mReader->getAttributeValue(indexSource);
int indexOffset = TestAttribute("offset");
if (indexOffset >= 0)
channel.mOffset = mReader->getAttributeValueAsInt(indexOffset);
// local URLS always start with a '#'. We don't support global URLs
if (attrSource[0] != '#')
ThrowException(format() << "Unsupported URL format in \"" << attrSource << "\" in source attribute of <vertex_weights> data <input> element");
channel.mAccessor = attrSource + 1;
// parse source URL to corresponding source
if (strcmp(attrSemantic, "JOINT") == 0)
pController.mWeightInputJoints = channel;
else if (strcmp(attrSemantic, "WEIGHT") == 0)
pController.mWeightInputWeights = channel;
else
ThrowException(format() << "Unknown semantic \"" << attrSemantic << "\" in <vertex_weights> data <input> element");
// skip inner data, if present
if (!mReader->isEmptyElement())
SkipElement();
}
else if (IsElement("vcount") && vertexCount > 0)
{
// read weight count per vertex
const char* text = GetTextContent();
size_t numWeights = 0;
for (std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it)
{
if (*text == 0)
ThrowException("Out of data while reading <vcount>");
*it = strtoul10(text, &text);
numWeights += *it;
SkipSpacesAndLineEnd(&text);
}
TestClosing("vcount");
// reserve weight count
pController.mWeights.resize(numWeights);
}
else if (IsElement("v") && vertexCount > 0)
{
// read JointIndex - WeightIndex pairs
const char* text = GetTextContent();
for (std::vector< std::pair<size_t, size_t> >::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it)
{
if (*text == 0)
ThrowException("Out of data while reading <vertex_weights>");
it->first = strtoul10(text, &text);
SkipSpacesAndLineEnd(&text);
if (*text == 0)
ThrowException("Out of data while reading <vertex_weights>");
it->second = strtoul10(text, &text);
SkipSpacesAndLineEnd(&text);
}
TestClosing("v");
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
{
if (strcmp(mReader->getNodeName(), "vertex_weights") != 0)
ThrowException("Expected end of <vertex_weights> element.");
break;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2b281d(%rip), %rsi # 0x569197
callq 0x2b5ca8
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x50(%rcx)
movl %eax, %r13d
movslq %eax, %rsi
leaq 0x128(%r14), %rdi
callq 0x2be974
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x2b6e3f
leaq 0x140(%r14), %rax
movq %rax, 0x60(%rsp)
leaq 0x30(%rsp), %r12
leaq 0xe8(%r14), %rax
movq %rax, 0x78(%rsp)
leaq 0x100(%r14), %rax
movq %rax, 0x70(%rsp)
leaq 0x120(%r14), %rax
movq %rax, 0x68(%rsp)
leaq 0xa8(%r14), %rax
movq %rax, 0x58(%rsp)
leaq 0xc0(%r14), %rax
movq %rax, 0x50(%rsp)
leaq 0xe0(%r14), %rax
movq %rax, 0x48(%rsp)
movabsq $0x100002600, %rbp # imm = 0x100002600
movl %r13d, 0x4(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %r15d
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %r15d
jne 0x2b6b98
cmpl $0x1, %eax
jne 0x2b6ebf
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
leaq 0x2d7fac(%rip), %rsi # 0x58ea01
callq 0x1a5f30
testl %r13d, %r13d
je 0x2b6ba6
testl %eax, %eax
jne 0x2b6ba6
movq %r12, 0x20(%rsp)
xorl %eax, %eax
movq %rax, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
movl $0x0, 0x8(%rsp)
movq %rax, 0x40(%rsp)
leaq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%rax)
movq %rbx, %rdi
leaq 0x2e646c(%rip), %rsi # 0x59cf0b
callq 0x2b5ca8
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x30(%rcx)
movq %rax, %r13
movq %rax, 0xa8(%rsp)
movq %rbx, %rdi
leaq 0x2e2dc1(%rip), %rsi # 0x599886
callq 0x2b5ca8
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x30(%rcx)
movq %rax, %r15
movq %rax, 0xa0(%rsp)
movq %rbx, %rdi
leaq 0x2dacbf(%rip), %rsi # 0x5917aa
callq 0x2b0fe2
testl %eax, %eax
js 0x2b6b07
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x50(%rcx)
cltq
movq %rax, 0x18(%rsp)
cmpb $0x23, (%r15)
jne 0x2b6f15
incq %r15
movq 0x28(%rsp), %r12
movq %r15, %rdi
callq 0x1a56a0
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
leaq 0x30(%rsp), %r12
callq 0x1a5830
movq %r13, %rdi
leaq 0x2e444e(%rip), %rsi # 0x59af93
callq 0x1a5f30
testl %eax, %eax
je 0x2b6d85
movq %r13, %rdi
leaq 0x2e546f(%rip), %rsi # 0x59bfcb
callq 0x1a5f30
testl %eax, %eax
jne 0x2b6f8b
movq 0x18(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rcx)
movq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1a64a0
movq 0x68(%rsp), %rax
jmp 0x2b6daf
cmpl $0x2, %eax
jne 0x2b6e0a
jmp 0x2b6e1e
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x2b6ebf
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
leaq 0x2e5573(%rip), %rsi # 0x59c140
callq 0x1a5f30
testl %r13d, %r13d
je 0x2b6c64
testl %eax, %eax
jne 0x2b6c64
movq %rbx, %rdi
callq 0x2b0f44
movq 0x128(%r14), %rcx
cmpq 0x130(%r14), %rcx
je 0x2b6de6
movb (%rax), %dl
xorl %r13d, %r13d
testb %dl, %dl
je 0x2b6e88
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jae 0x2b6c19
xorl %esi, %esi
jmp 0x2b6c38
xorl %esi, %esi
leal (%rsi,%rsi,4), %esi
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rsi,2), %esi
movb 0x1(%rax), %dl
incq %rax
leal -0x3a(%rdx), %edi
cmpb $-0xb, %dil
ja 0x2b6c1b
movl %esi, %esi
movq %rsi, (%rcx)
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0x2b6c4f
btq %rdx, %rbp
jae 0x2b6c4f
incq %rax
jmp 0x2b6c3b
addq %rsi, %r13
addq $0x8, %rcx
cmpq 0x130(%r14), %rcx
jne 0x2b6c04
jmp 0x2b6de9
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x2b6ebf
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
cmpb $0x76, (%rax)
jne 0x2b6d78
testl %r13d, %r13d
je 0x2b6d78
cmpb $0x0, 0x1(%rax)
jne 0x2b6d78
movq %rbx, %rdi
callq 0x2b0f44
movq 0x140(%r14), %rcx
cmpq 0x148(%r14), %rcx
je 0x2b6d64
movb (%rax), %dl
testb %dl, %dl
je 0x2b6ede
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jae 0x2b6cd0
xorl %edx, %edx
jmp 0x2b6cef
xorl %esi, %esi
leal (%rsi,%rsi,4), %esi
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rsi,2), %esi
movb 0x1(%rax), %dl
incq %rax
leal -0x3a(%rdx), %edi
cmpb $-0xb, %dil
ja 0x2b6cd2
movl %esi, %edx
movq %rdx, (%rcx)
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0x2b6d0f
btq %rdx, %rbp
jae 0x2b6d06
incq %rax
jmp 0x2b6cf2
testq %rdx, %rdx
je 0x2b6e51
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jae 0x2b6d1c
xorl %edx, %edx
jmp 0x2b6d3b
xorl %esi, %esi
leal (%rsi,%rsi,4), %esi
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rsi,2), %esi
movb 0x1(%rax), %dl
incq %rax
leal -0x3a(%rdx), %edi
cmpb $-0xb, %dil
ja 0x2b6d1e
movl %esi, %edx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %edx
cmpq $0x20, %rdx
ja 0x2b6d53
btq %rdx, %rbp
jae 0x2b6d53
incq %rax
jmp 0x2b6d3f
addq $0x10, %rcx
cmpq 0x148(%r14), %rcx
jne 0x2b6cbb
movq %rbx, %rdi
leaq 0x2ab84e(%rip), %rsi # 0x5625bc
callq 0x2b4810
jmp 0x2b6e0a
movq %rbx, %rdi
callq 0x2b13ae
jmp 0x2b6e0a
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rcx)
movq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1a64a0
movq 0x48(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
jne 0x2b6dcd
movq %rbx, %rdi
callq 0x2b13ae
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b6e05
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2b6e05
xorl %r13d, %r13d
movq %rbx, %rdi
leaq 0x2e534d(%rip), %rsi # 0x59c140
callq 0x2b4810
movq 0x60(%rsp), %rdi
movq %r13, %rsi
callq 0x2be9a6
movl 0x4(%rsp), %r13d
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x2b6a17
jmp 0x2b6e3f
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x2e5172(%rip), %rsi # 0x59bfa1
movq %rax, %rdi
callq 0x1a5f30
testl %eax, %eax
jne 0x2b7001
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2e5306(%rip), %rsi # 0x59c16a
leaq 0x2e5329(%rip), %rdx # 0x59c194
leaq 0xb0(%rsp), %rdi
callq 0x209290
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b08dc
leaq 0xc0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2e52ac(%rip), %rsi # 0x59c147
leaq 0x2e52c7(%rip), %rdx # 0x59c169
leaq 0xb0(%rsp), %rdi
callq 0x209290
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b08dc
leaq 0x2e6386(%rip), %rdi # 0x59d24c
leaq 0x2e63ae(%rip), %rsi # 0x59d27b
leaq 0x2e641f(%rip), %rcx # 0x59d2f3
movl $0x178, %edx # imm = 0x178
callq 0x1a5270
leaq 0xc0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2e5279(%rip), %rsi # 0x59c16a
leaq 0x2e529c(%rip), %rdx # 0x59c194
leaq 0xb0(%rsp), %rdi
callq 0x209290
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b08dc
leaq 0xb0(%rsp), %rdi
callq 0x1a6170
leaq 0x2e50f2(%rip), %rsi # 0x59c01b
leaq 0xb0(%rsp), %rdi
movl $0x1b, %edx
callq 0x1a61e0
leaq 0xb0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x2be92a
movq %rax, %r14
leaq 0x2e517c(%rip), %rsi # 0x59c0d6
movl $0x3e, %edx
movq %rax, %rdi
callq 0x1a61e0
addq $0x8, %r14
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0x1a5690
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b08dc
leaq 0xb0(%rsp), %rdi
callq 0x1a6170
leaq 0x2e50df(%rip), %rsi # 0x59c07e
leaq 0xb0(%rsp), %rdi
movl $0x12, %edx
callq 0x1a61e0
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2be92a
movq %rax, %r14
leaq 0x2e5145(%rip), %rsi # 0x59c115
movl $0x2a, %edx
movq %rax, %rdi
callq 0x1a61e0
addq $0x8, %r14
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0x1a5690
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b08dc
leaq 0xc0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2e5181(%rip), %rsi # 0x59c195
leaq 0x2e51a3(%rip), %rdx # 0x59c1be
leaq 0xb0(%rsp), %rdi
callq 0x209290
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b08dc
jmp 0x2b7044
jmp 0x2b70bf
jmp 0x2b70e1
movq %rax, %rbx
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b7071
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2b7071
jmp 0x2b706e
jmp 0x2b70a6
movq %rax, %rbx
movq 0x4f4f18(%rip), %rsi # 0x7abf90
leaq 0xb0(%rsp), %rdi
callq 0x1a5d00
leaq 0x120(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2b70a9
jmp 0x2b70a6
jmp 0x2b70a6
jmp 0x2b70a6
jmp 0x2b70a6
jmp 0x2b70a6
jmp 0x2b70bf
jmp 0x2b70e1
jmp 0x2b70bf
jmp 0x2b70e1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2b70e4
movq 0x30(%rsp), %rsi
jmp 0x2b70d7
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b70e4
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2b70e4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaParser.cpp |
Assimp::ColladaParser::ReadEffectFloat(float&) | void ColladaParser::ReadEffectFloat(ai_real& pFloat)
{
while (mReader->read())
{
if (mReader->getNodeType() == irr::io::EXN_ELEMENT) {
if (IsElement("float"))
{
// text content contains a single floats
const char* content = GetTextContent();
content = fast_atoreal_move<ai_real>(content, pFloat);
SkipSpacesAndLineEnd(&content);
TestClosing("float");
}
else
{
// ignore the rest
SkipElement();
}
}
else if (mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
break;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x2b9134
leaq 0x2e2014(%rip), %r15 # 0x59b0d0
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ebp
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %ebp
jne 0x2b90ff
cmpl $0x1, %eax
jne 0x2b913f
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a5f30
movq %r14, %rdi
testl %eax, %eax
je 0x2b9106
callq 0x2b13ae
jmp 0x2b9126
cmpl $0x2, %eax
jne 0x2b9126
jmp 0x2b9134
callq 0x2b0f44
movq %rax, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2470c9
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b4810
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x2b90bc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e4106(%rip), %rdi # 0x59d24c
leaq 0x2e412e(%rip), %rsi # 0x59d27b
leaq 0x2e419f(%rip), %rcx # 0x59d2f3
movl $0x178, %edx # imm = 0x178
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaParser.cpp |
Assimp::ColladaParser::ReadNodeTransformation(Assimp::Collada::Node*, Assimp::Collada::TransformType) | void ColladaParser::ReadNodeTransformation(Node* pNode, TransformType pType)
{
if (mReader->isEmptyElement())
return;
std::string tagName = mReader->getNodeName();
Transform tf;
tf.mType = pType;
// read SID
int indexSID = TestAttribute("sid");
if (indexSID >= 0)
tf.mID = mReader->getAttributeValue(indexSID);
// how many parameters to read per transformation type
static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
const char* content = GetTextContent();
// read as many parameters and store in the transformation
for (unsigned int a = 0; a < sNumParameters[pType]; a++)
{
// read a number
content = fast_atoreal_move<ai_real>(content, tf.f[a]);
// skip whitespace after it
SkipSpacesAndLineEnd(&content);
}
// place the transformation at the queue of the node
pNode->mTransforms.push_back(tf);
// and consume the closing tag
TestClosing(tagName.c_str());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
jne 0x2bcc47
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movq %rax, %rsi
callq 0x23ca1c
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl %ebp, 0x10(%rax)
leaq 0x2df911(%rip), %rsi # 0x59c468
movq %rbx, %rdi
callq 0x2b0fe2
testl %eax, %eax
js 0x2bcb97
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x30(%rcx)
movq %rax, %r15
leaq 0x20(%rsp), %r12
movq 0x8(%r12), %r13
movq %rax, %rdi
callq 0x1a56a0
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x1a5830
movq %rbx, %rdi
callq 0x2b0f44
movl %ebp, %ecx
leaq 0x2def58(%rip), %rdx # 0x59bb00
movl (%rdx,%rcx,4), %r15d
leaq 0x44(%rsp), %r12
cmpl $0x1, %r15d
adcl $0x0, %r15d
xorl %r13d, %r13d
movabsq $0x100002600, %rbp # imm = 0x100002600
leaq (%r12,%r13,4), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x2470c9
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x2bcbeb
btq %rcx, %rbp
jae 0x2bcbeb
incq %rax
jmp 0x2bcbd7
incq %r13
cmpq %r15, %r13
jne 0x2bcbc6
subq $-0x80, %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x2bfa90
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x2b4810
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2bcc2c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bcc47
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2bcc5d
jmp 0x2bcc5d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2bcc7c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bcc97
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaParser.cpp |
Assimp::ColladaParser::CalculateResultTransform(std::vector<Assimp::Collada::Transform, std::allocator<Assimp::Collada::Transform>> const&) const | aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector<Transform>& pTransforms) const
{
aiMatrix4x4 res;
for (std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it)
{
const Transform& tf = *it;
switch (tf.mType)
{
case TF_LOOKAT:
{
aiVector3D pos(tf.f[0], tf.f[1], tf.f[2]);
aiVector3D dstPos(tf.f[3], tf.f[4], tf.f[5]);
aiVector3D up = aiVector3D(tf.f[6], tf.f[7], tf.f[8]).Normalize();
aiVector3D dir = aiVector3D(dstPos - pos).Normalize();
aiVector3D right = (dir ^ up).Normalize();
res *= aiMatrix4x4(
right.x, up.x, -dir.x, pos.x,
right.y, up.y, -dir.y, pos.y,
right.z, up.z, -dir.z, pos.z,
0, 0, 0, 1);
break;
}
case TF_ROTATE:
{
aiMatrix4x4 rot;
ai_real angle = tf.f[3] * ai_real(AI_MATH_PI) / ai_real(180.0);
aiVector3D axis(tf.f[0], tf.f[1], tf.f[2]);
aiMatrix4x4::Rotation(angle, axis, rot);
res *= rot;
break;
}
case TF_TRANSLATE:
{
aiMatrix4x4 trans;
aiMatrix4x4::Translation(aiVector3D(tf.f[0], tf.f[1], tf.f[2]), trans);
res *= trans;
break;
}
case TF_SCALE:
{
aiMatrix4x4 scale(tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
res *= scale;
break;
}
case TF_SKEW:
// TODO: (thom)
ai_assert(false);
break;
case TF_MATRIX:
{
aiMatrix4x4 mat(tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7],
tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
res *= mat;
break;
}
default:
ai_assert(false);
break;
}
}
return res;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x3f800000, %eax # imm = 0x3F800000
movl %eax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl %eax, 0x14(%rdi)
movups %xmm0, 0x18(%rdi)
movl %eax, 0x28(%rdi)
movups %xmm0, 0x2c(%rdi)
movl %eax, 0x3c(%rdi)
movq (%rdx), %r15
cmpq 0x8(%rdx), %r15
je 0x2be161
movq %rdx, %r14
movsd 0x29dff2(%rip), %xmm7 # 0x55b2d0
movsd 0x29e259(%rip), %xmm10 # 0x55b540
leaq 0x2de7f6(%rip), %r12 # 0x59bae4
movaps %xmm10, %xmm5
movl 0x20(%r15), %eax
cmpq $0x5, %rax
ja 0x2be192
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movss 0x24(%r15), %xmm12
movaps %xmm12, 0x30(%rsp)
movss 0x28(%r15), %xmm14
movss %xmm14, 0x20(%rsp)
movss 0x2c(%r15), %xmm11
movss %xmm11, 0xc(%rsp)
movss 0x30(%r15), %xmm3
movss 0x34(%r15), %xmm2
movss 0x38(%r15), %xmm1
movss 0x3c(%r15), %xmm4
movss 0x40(%r15), %xmm15
movss 0x44(%r15), %xmm6
movaps %xmm15, %xmm9
mulss %xmm15, %xmm9
movaps %xmm4, %xmm10
mulss %xmm4, %xmm10
addss %xmm9, %xmm10
movaps %xmm6, %xmm9
mulss %xmm6, %xmm9
addss %xmm10, %xmm9
sqrtss %xmm9, %xmm9
movss 0x29e22a(%rip), %xmm10 # 0x55b5b0
movaps %xmm10, %xmm8
divss %xmm9, %xmm8
mulss %xmm8, %xmm4
mulss %xmm8, %xmm15
mulss %xmm6, %xmm8
subss %xmm12, %xmm3
subss %xmm14, %xmm2
subss %xmm11, %xmm1
movaps %xmm2, %xmm6
mulss %xmm2, %xmm6
movaps %xmm3, %xmm9
mulss %xmm3, %xmm9
addss %xmm6, %xmm9
movaps %xmm1, %xmm6
mulss %xmm1, %xmm6
addss %xmm9, %xmm6
sqrtss %xmm6, %xmm6
movaps %xmm10, %xmm12
divss %xmm6, %xmm12
mulss %xmm12, %xmm3
mulss %xmm12, %xmm2
mulss %xmm1, %xmm12
movaps %xmm12, 0x60(%rsp)
movaps %xmm15, %xmm1
mulss %xmm12, %xmm1
movaps %xmm2, %xmm14
movaps %xmm8, 0x10(%rsp)
mulss %xmm8, %xmm14
subss %xmm1, %xmm14
movaps %xmm3, %xmm11
movaps %xmm8, %xmm1
mulss %xmm3, %xmm1
mulss %xmm4, %xmm12
subss %xmm1, %xmm12
movaps %xmm4, %xmm1
mulss %xmm2, %xmm1
mulss %xmm15, %xmm3
subss %xmm1, %xmm3
movaps %xmm12, %xmm1
mulss %xmm12, %xmm1
movaps %xmm14, %xmm6
mulss %xmm14, %xmm6
addss %xmm1, %xmm6
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
addss %xmm6, %xmm1
xorps %xmm6, %xmm6
sqrtss %xmm1, %xmm6
divss %xmm6, %xmm10
mulss %xmm10, %xmm14
mulss %xmm10, %xmm12
mulss %xmm3, %xmm10
movaps %xmm5, %xmm3
unpckhpd %xmm5, %xmm3 # xmm3 = xmm3[1],xmm5[1]
movaps %xmm3, %xmm6
mulss %xmm12, %xmm6
movaps %xmm14, %xmm9
mulss %xmm7, %xmm9
addss %xmm6, %xmm9
movaps %xmm7, %xmm13
shufps $0xff, %xmm7, %xmm13 # xmm13 = xmm13[3,3],xmm7[3,3]
movaps %xmm10, %xmm6
mulss %xmm13, %xmm6
addss %xmm9, %xmm6
movaps %xmm0, %xmm8
shufps $0xff, %xmm0, %xmm8 # xmm8 = xmm8[3,3],xmm0[3,3]
movaps %xmm8, %xmm9
xorps %xmm1, %xmm1
mulss %xmm1, %xmm9
addss %xmm6, %xmm9
movaps %xmm9, 0x50(%rsp)
movaps 0x29ddd6(%rip), %xmm1 # 0x55b2a0
xorps %xmm1, %xmm2
unpcklps %xmm2, %xmm15 # xmm15 = xmm15[0],xmm2[0],xmm15[1],xmm2[1]
movaps %xmm15, 0x70(%rsp)
xorps %xmm1, %xmm11
unpcklps %xmm11, %xmm4 # xmm4 = xmm4[0],xmm11[0],xmm4[1],xmm11[1]
movaps %xmm4, 0x40(%rsp)
movaps %xmm5, %xmm2
shufps $0xaa, %xmm5, %xmm2 # xmm2 = xmm2[2,2],xmm5[2,2]
mulps %xmm15, %xmm2
movaps %xmm7, %xmm6
shufps $0x0, %xmm7, %xmm6 # xmm6 = xmm6[0,0],xmm7[0,0]
mulps %xmm4, %xmm6
addps %xmm2, %xmm6
movaps 0x60(%rsp), %xmm4
xorps %xmm1, %xmm4
movaps 0x10(%rsp), %xmm2
unpcklps %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
movaps %xmm2, 0x10(%rsp)
mulps %xmm13, %xmm2
addps %xmm6, %xmm2
mulss 0x20(%rsp), %xmm3
movaps 0x30(%rsp), %xmm6
mulss %xmm7, %xmm6
addss %xmm3, %xmm6
mulss 0xc(%rsp), %xmm13
addss %xmm6, %xmm13
addss %xmm8, %xmm13
xorps %xmm1, %xmm1
mulps %xmm1, %xmm8
addps %xmm2, %xmm8
movaps %xmm8, 0x60(%rsp)
movaps %xmm5, %xmm9
shufps $0x55, %xmm5, %xmm9 # xmm9 = xmm9[1,1],xmm5[1,1]
movaps %xmm9, %xmm2
mulss %xmm12, %xmm2
movaps %xmm0, %xmm15
unpckhpd %xmm0, %xmm15 # xmm15 = xmm15[1],xmm0[1]
movaps %xmm14, %xmm3
mulss %xmm15, %xmm3
addss %xmm2, %xmm3
movaps %xmm7, %xmm2
unpckhpd %xmm7, %xmm2 # xmm2 = xmm2[1],xmm7[1]
movaps %xmm10, %xmm1
mulss %xmm2, %xmm1
addss %xmm3, %xmm1
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3 # xmm3 = xmm3[1,1],xmm0[1,1]
movaps %xmm3, %xmm11
mulss 0x29e09c(%rip), %xmm11 # 0x55b638
addss %xmm1, %xmm11
movaps 0x70(%rsp), %xmm1
mulps %xmm9, %xmm1
movaps %xmm0, %xmm4
shufps $0xaa, %xmm0, %xmm4 # xmm4 = xmm4[2,2],xmm0[2,2]
mulps 0x40(%rsp), %xmm4
addps %xmm1, %xmm4
movaps %xmm7, %xmm1
shufps $0xaa, %xmm7, %xmm1 # xmm1 = xmm1[2,2],xmm7[2,2]
mulps 0x10(%rsp), %xmm1
addps %xmm4, %xmm1
movss 0x20(%rsp), %xmm4
mulss %xmm4, %xmm9
movaps 0x30(%rsp), %xmm6
mulss %xmm6, %xmm15
addss %xmm9, %xmm15
movss 0xc(%rsp), %xmm8
mulss %xmm8, %xmm2
addss %xmm15, %xmm2
addss %xmm3, %xmm2
movaps %xmm3, %xmm9
mulps 0x29dd9d(%rip), %xmm9 # 0x55b3a0
addps %xmm1, %xmm9
movaps %xmm5, %xmm1
mulss %xmm12, %xmm1
movaps %xmm14, %xmm3
mulss %xmm0, %xmm3
addss %xmm1, %xmm3
shufps $0x55, %xmm7, %xmm7 # xmm7 = xmm7[1,1,1,1]
movaps %xmm10, %xmm1
mulss %xmm7, %xmm1
addss %xmm3, %xmm1
movaps %xmm5, %xmm3
shufps $0xff, %xmm5, %xmm3 # xmm3 = xmm3[3,3],xmm5[3,3]
movaps %xmm3, %xmm15
mulss 0x29dff9(%rip), %xmm15 # 0x55b638
addss %xmm1, %xmm15
movaps %xmm4, %xmm1
mulss %xmm5, %xmm1
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
mulps 0x70(%rsp), %xmm5
mulss %xmm0, %xmm6
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
mulps 0x40(%rsp), %xmm0
addps %xmm5, %xmm0
movaps 0x10(%rsp), %xmm5
mulps %xmm7, %xmm5
addps %xmm0, %xmm5
addss %xmm1, %xmm6
mulss %xmm8, %xmm7
addss %xmm6, %xmm7
addss %xmm3, %xmm7
movaps %xmm3, %xmm4
mulps 0x29dd16(%rip), %xmm4 # 0x55b3a0
movaps 0x50(%rsp), %xmm6
addps %xmm5, %xmm4
movss 0x34(%rbx), %xmm0
mulss %xmm0, %xmm12
movss 0x30(%rbx), %xmm3
mulss %xmm3, %xmm14
addss %xmm12, %xmm14
movss 0x38(%rbx), %xmm5
mulss %xmm5, %xmm10
addss %xmm14, %xmm10
movss 0x20(%rsp), %xmm8
mulss %xmm0, %xmm8
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
mulps 0x70(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
mulss %xmm3, %xmm1
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps 0x40(%rsp), %xmm3
addps %xmm0, %xmm3
movss 0xc(%rsp), %xmm0
mulss %xmm5, %xmm0
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
mulps 0x10(%rsp), %xmm5
addps %xmm3, %xmm5
addss %xmm8, %xmm1
addss %xmm0, %xmm1
movss 0x3c(%rbx), %xmm0
addss %xmm0, %xmm1
mulss 0x29df24(%rip), %xmm0 # 0x55b638
addss %xmm0, %xmm10
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
addps %xmm5, %xmm0
movaps 0x60(%rsp), %xmm3
movlhps %xmm3, %xmm6 # xmm6 = xmm6[0],xmm3[0]
shufps $0xd4, %xmm3, %xmm13 # xmm13 = xmm13[0,1],xmm3[1,3]
shufps $0x28, %xmm13, %xmm6 # xmm6 = xmm6[0,2],xmm13[2,0]
movlhps %xmm9, %xmm11 # xmm11 = xmm11[0],xmm9[0]
shufps $0xd4, %xmm9, %xmm2 # xmm2 = xmm2[0,1],xmm9[1,3]
shufps $0x28, %xmm2, %xmm11 # xmm11 = xmm11[0,2],xmm2[2,0]
movlhps %xmm4, %xmm15 # xmm15 = xmm15[0],xmm4[0]
shufps $0xd4, %xmm4, %xmm7 # xmm7 = xmm7[0,1],xmm4[1,3]
shufps $0x28, %xmm7, %xmm15 # xmm15 = xmm15[0,2],xmm7[2,0]
movlhps %xmm0, %xmm10 # xmm10 = xmm10[0],xmm0[0]
shufps $0xd4, %xmm0, %xmm1 # xmm1 = xmm1[0,1],xmm0[1,3]
shufps $0x28, %xmm1, %xmm10 # xmm10 = xmm10[0,2],xmm1[2,0]
movaps %xmm15, %xmm7
jmp 0x2be108
movups 0x24(%r15), %xmm1
movups 0x34(%r15), %xmm8
movups 0x44(%r15), %xmm9
movups 0x54(%r15), %xmm2
movaps %xmm5, %xmm3
shufps $0xaa, %xmm5, %xmm3 # xmm3 = xmm3[2,2],xmm5[2,2]
mulps %xmm8, %xmm3
movaps %xmm7, %xmm4
shufps $0x0, %xmm7, %xmm4 # xmm4 = xmm4[0,0],xmm7[0,0]
mulps %xmm1, %xmm4
addps %xmm3, %xmm4
movaps %xmm7, %xmm3
shufps $0xff, %xmm7, %xmm3 # xmm3 = xmm3[3,3],xmm7[3,3]
mulps %xmm9, %xmm3
addps %xmm4, %xmm3
movaps %xmm0, %xmm6
shufps $0xff, %xmm0, %xmm6 # xmm6 = xmm6[3,3],xmm0[3,3]
mulps %xmm2, %xmm6
addps %xmm3, %xmm6
movaps %xmm5, %xmm3
shufps $0x55, %xmm5, %xmm3 # xmm3 = xmm3[1,1],xmm5[1,1]
mulps %xmm8, %xmm3
movaps %xmm0, %xmm4
shufps $0xaa, %xmm0, %xmm4 # xmm4 = xmm4[2,2],xmm0[2,2]
mulps %xmm1, %xmm4
addps %xmm3, %xmm4
movaps %xmm7, %xmm3
shufps $0xaa, %xmm7, %xmm3 # xmm3 = xmm3[2,2],xmm7[2,2]
mulps %xmm9, %xmm3
addps %xmm4, %xmm3
movaps %xmm0, %xmm11
shufps $0x55, %xmm0, %xmm11 # xmm11 = xmm11[1,1],xmm0[1,1]
mulps %xmm2, %xmm11
addps %xmm3, %xmm11
movaps %xmm5, %xmm3
shufps $0x0, %xmm5, %xmm3 # xmm3 = xmm3[0,0],xmm5[0,0]
mulps %xmm8, %xmm3
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
mulps %xmm1, %xmm0
addps %xmm3, %xmm0
shufps $0x55, %xmm7, %xmm7 # xmm7 = xmm7[1,1,1,1]
mulps %xmm9, %xmm7
addps %xmm0, %xmm7
shufps $0xff, %xmm5, %xmm5 # xmm5 = xmm5[3,3,3,3]
mulps %xmm2, %xmm5
addps %xmm5, %xmm7
movaps %xmm10, %xmm0
shufps $0x0, %xmm10, %xmm0 # xmm0 = xmm0[0,0],xmm10[0,0]
mulps %xmm8, %xmm0
movaps %xmm10, %xmm3
shufps $0xaa, %xmm10, %xmm3 # xmm3 = xmm3[2,2],xmm10[2,2]
mulps %xmm1, %xmm3
addps %xmm0, %xmm3
movaps %xmm10, %xmm0
shufps $0xff, %xmm10, %xmm0 # xmm0 = xmm0[3,3],xmm10[3,3]
mulps %xmm9, %xmm0
addps %xmm3, %xmm0
shufps $0x55, %xmm10, %xmm10 # xmm10 = xmm10[1,1,1,1]
mulps %xmm2, %xmm10
addps %xmm0, %xmm10
jmp 0x2be108
movss 0x24(%r15), %xmm8
movss 0x28(%r15), %xmm15
movss %xmm15, 0x20(%rsp)
movss 0x2c(%r15), %xmm1
movss %xmm1, 0x10(%rsp)
movaps %xmm5, %xmm6
unpckhpd %xmm5, %xmm6 # xmm6 = xmm6[1],xmm5[1]
movaps %xmm6, %xmm4
xorps %xmm13, %xmm13
mulss %xmm13, %xmm4
movaps %xmm7, %xmm2
addss %xmm4, %xmm2
movaps %xmm7, %xmm9
shufps $0xff, %xmm7, %xmm9 # xmm9 = xmm9[3,3],xmm7[3,3]
movaps %xmm9, %xmm3
mulss %xmm13, %xmm3
addss %xmm3, %xmm2
movaps %xmm0, %xmm1
shufps $0xff, %xmm0, %xmm1 # xmm1 = xmm1[3,3],xmm0[3,3]
movaps %xmm7, %xmm11
mulss %xmm13, %xmm11
movaps %xmm11, %xmm12
addss %xmm6, %xmm12
addss %xmm4, %xmm11
addss %xmm9, %xmm11
movaps %xmm1, %xmm14
mulss %xmm15, %xmm6
movaps %xmm8, %xmm15
movss %xmm8, 0x30(%rsp)
movaps %xmm8, %xmm4
mulss %xmm7, %xmm4
addss %xmm6, %xmm4
movss 0x10(%rsp), %xmm6
mulss %xmm6, %xmm9
addss %xmm4, %xmm9
addss %xmm1, %xmm9
mulss %xmm13, %xmm1
addss %xmm2, %xmm1
movaps %xmm1, 0x50(%rsp)
addss %xmm3, %xmm12
unpcklps %xmm11, %xmm12 # xmm12 = xmm12[0],xmm11[0],xmm12[1],xmm11[1]
xorps %xmm1, %xmm1
mulps %xmm1, %xmm14
addps %xmm12, %xmm14
movaps %xmm14, 0x40(%rsp)
movaps %xmm5, %xmm2
shufps $0x55, %xmm5, %xmm2 # xmm2 = xmm2[1,1],xmm5[1,1]
movaps %xmm2, %xmm3
mulss %xmm13, %xmm3
movaps %xmm0, %xmm12
unpckhpd %xmm0, %xmm12 # xmm12 = xmm12[1],xmm0[1]
movaps %xmm12, %xmm4
addss %xmm3, %xmm4
movaps %xmm7, %xmm8
unpckhpd %xmm7, %xmm8 # xmm8 = xmm8[1],xmm7[1]
movaps %xmm8, %xmm14
mulss %xmm13, %xmm14
addss %xmm14, %xmm4
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
movaps %xmm1, %xmm11
mulss %xmm13, %xmm11
addss %xmm4, %xmm11
movaps %xmm15, %xmm4
mulss %xmm12, %xmm4
mulss %xmm13, %xmm12
movaps %xmm12, %xmm15
addss %xmm3, %xmm12
addss %xmm2, %xmm15
mulss 0x20(%rsp), %xmm2
addss %xmm4, %xmm2
addss %xmm8, %xmm12
mulss %xmm6, %xmm8
addss %xmm2, %xmm8
addss %xmm1, %xmm8
movaps %xmm1, %xmm13
addss %xmm14, %xmm15
unpcklps %xmm12, %xmm15 # xmm15 = xmm15[0],xmm12[0],xmm15[1],xmm12[1]
mulps 0x29d9ed(%rip), %xmm13 # 0x55b3a0
addps %xmm15, %xmm13
movaps %xmm5, %xmm1
xorps %xmm3, %xmm3
mulss %xmm3, %xmm1
movaps %xmm0, %xmm4
addss %xmm1, %xmm4
shufps $0x55, %xmm7, %xmm7 # xmm7 = xmm7[1,1,1,1]
movaps %xmm7, %xmm2
mulss %xmm3, %xmm2
addss %xmm2, %xmm4
movaps %xmm5, %xmm14
shufps $0xff, %xmm5, %xmm14 # xmm14 = xmm14[3,3],xmm5[3,3]
movaps %xmm14, %xmm12
mulss %xmm3, %xmm12
addss %xmm4, %xmm12
movss 0x30(%rsp), %xmm6
movaps %xmm6, %xmm4
mulss %xmm0, %xmm4
mulss %xmm3, %xmm0
movaps %xmm0, %xmm15
addss %xmm1, %xmm0
addss %xmm5, %xmm15
movss 0x20(%rsp), %xmm3
mulss %xmm3, %xmm5
addss %xmm4, %xmm5
addss %xmm7, %xmm0
mulss 0x10(%rsp), %xmm7
addss %xmm5, %xmm7
addss %xmm14, %xmm7
movaps %xmm14, %xmm5
addss %xmm2, %xmm15
unpcklps %xmm0, %xmm15 # xmm15 = xmm15[0],xmm0[0],xmm15[1],xmm0[1]
mulps 0x29d95f(%rip), %xmm5 # 0x55b3a0
addps %xmm15, %xmm5
movaps %xmm10, %xmm4
unpckhpd %xmm10, %xmm4 # xmm4 = xmm4[1],xmm10[1]
movaps %xmm4, %xmm15
mulss %xmm4, %xmm6
movss %xmm6, 0x30(%rsp)
xorps %xmm1, %xmm1
mulss %xmm1, %xmm4
movaps %xmm4, %xmm2
addss %xmm10, %xmm2
mulss %xmm10, %xmm3
movaps %xmm10, %xmm14
movaps %xmm10, %xmm0
movaps %xmm10, %xmm6
mulss %xmm1, %xmm6
addss %xmm6, %xmm15
shufps $0xff, %xmm10, %xmm14 # xmm14 = xmm14[3,3],xmm10[3,3]
movaps %xmm14, %xmm10
mulss %xmm1, %xmm10
addss %xmm10, %xmm15
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, %xmm1
mulss 0x29db91(%rip), %xmm1 # 0x55b638
addss %xmm15, %xmm1
addss %xmm10, %xmm2
addss %xmm6, %xmm4
movaps 0x50(%rsp), %xmm6
addss %xmm14, %xmm4
unpcklps %xmm4, %xmm2 # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
addss 0x30(%rsp), %xmm3
mulss 0x10(%rsp), %xmm14
addss %xmm3, %xmm14
addss %xmm0, %xmm14
mulps 0x29d8c0(%rip), %xmm0 # 0x55b3a0
addps %xmm2, %xmm0
movaps 0x40(%rsp), %xmm2
movlhps %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
shufps $0xd4, %xmm2, %xmm9 # xmm9 = xmm9[0,1],xmm2[1,3]
shufps $0x28, %xmm9, %xmm6 # xmm6 = xmm6[0,2],xmm9[2,0]
movlhps %xmm13, %xmm11 # xmm11 = xmm11[0],xmm13[0]
shufps $0xd4, %xmm13, %xmm8 # xmm8 = xmm8[0,1],xmm13[1,3]
shufps $0x28, %xmm8, %xmm11 # xmm11 = xmm11[0,2],xmm8[2,0]
movlhps %xmm5, %xmm12 # xmm12 = xmm12[0],xmm5[0]
shufps $0xd4, %xmm5, %xmm7 # xmm7 = xmm7[0,1],xmm5[1,3]
shufps $0x28, %xmm7, %xmm12 # xmm12 = xmm12[0,2],xmm7[2,0]
movlhps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
shufps $0xd4, %xmm0, %xmm14 # xmm14 = xmm14[0,1],xmm0[1,3]
shufps $0x28, %xmm14, %xmm1 # xmm1 = xmm1[0,2],xmm14[2,0]
movaps %xmm12, %xmm7
movaps %xmm1, %xmm10
jmp 0x2be108
movss 0x24(%r15), %xmm3
movss 0x28(%r15), %xmm9
movaps %xmm5, %xmm2
shufps $0xaa, %xmm5, %xmm2 # xmm2 = xmm2[2,2],xmm5[2,2]
mulps %xmm9, %xmm2
movaps %xmm7, %xmm1
xorps %xmm15, %xmm15
mulss %xmm15, %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
addps %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
movaps %xmm3, %xmm4
mulss %xmm7, %xmm4
addss %xmm2, %xmm4
movaps %xmm7, %xmm2
shufps $0xff, %xmm7, %xmm2 # xmm2 = xmm2[3,3],xmm7[3,3]
movaps %xmm2, %xmm6
mulss %xmm15, %xmm6
addss %xmm6, %xmm4
movaps %xmm10, %xmm12
movaps %xmm0, %xmm10
shufps $0xff, %xmm0, %xmm10 # xmm10 = xmm10[3,3],xmm0[3,3]
movd 0x2c(%r15), %xmm8
movq %xmm8, %xmm8 # xmm8 = xmm8[0],zero
xorps %xmm11, %xmm11
shufps $0xe2, %xmm11, %xmm8 # xmm8 = xmm8[2,0],xmm11[2,3]
mulps %xmm8, %xmm2
addps %xmm1, %xmm2
movaps %xmm10, %xmm14
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
addss %xmm6, %xmm1
addss %xmm10, %xmm1
mulss %xmm15, %xmm10
addss %xmm4, %xmm10
mulps %xmm11, %xmm14
addps %xmm2, %xmm14
movaps %xmm5, %xmm2
shufps $0x55, %xmm5, %xmm2 # xmm2 = xmm2[1,1],xmm5[1,1]
mulps %xmm9, %xmm2
movaps %xmm0, %xmm4
unpckhpd %xmm0, %xmm4 # xmm4 = xmm4[1],xmm0[1]
movaps %xmm3, %xmm13
mulss %xmm4, %xmm13
mulss %xmm15, %xmm4
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
addps %xmm2, %xmm4
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
addss %xmm2, %xmm13
movaps %xmm7, %xmm2
unpckhpd %xmm7, %xmm2 # xmm2 = xmm2[1],xmm7[1]
mulss %xmm15, %xmm2
addss %xmm2, %xmm13
movaps %xmm0, %xmm11
shufps $0x55, %xmm0, %xmm11 # xmm11 = xmm11[1,1],xmm0[1,1]
movaps %xmm7, %xmm6
shufps $0xaa, %xmm7, %xmm6 # xmm6 = xmm6[2,2],xmm7[2,2]
mulps %xmm8, %xmm6
addps %xmm4, %xmm6
shufps $0x55, %xmm4, %xmm4 # xmm4 = xmm4[1,1,1,1]
addss %xmm2, %xmm4
movaps %xmm11, %xmm2
addss %xmm11, %xmm4
mulss %xmm15, %xmm11
addss %xmm13, %xmm11
mulps 0x29d765(%rip), %xmm2 # 0x55b3a0
addps %xmm6, %xmm2
movaps %xmm5, %xmm6
shufps $0x0, %xmm5, %xmm6 # xmm6 = xmm6[0,0],xmm5[0,0]
mulps %xmm9, %xmm6
movaps %xmm3, %xmm13
mulss %xmm0, %xmm13
mulss %xmm15, %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
addps %xmm6, %xmm0
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
addss %xmm6, %xmm13
shufps $0x55, %xmm7, %xmm7 # xmm7 = xmm7[1,1,1,1]
movaps %xmm8, %xmm6
mulps %xmm7, %xmm6
mulss %xmm15, %xmm7
addss %xmm7, %xmm13
shufps $0xff, %xmm5, %xmm5 # xmm5 = xmm5[3,3,3,3]
addps %xmm0, %xmm6
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
addss %xmm7, %xmm0
movaps %xmm5, %xmm7
mulss %xmm15, %xmm7
addss %xmm13, %xmm7
movaps %xmm5, %xmm13
mulps 0x29d6fc(%rip), %xmm13 # 0x55b3a0
addps %xmm6, %xmm13
addss %xmm5, %xmm0
movaps %xmm12, %xmm6
shufps $0x0, %xmm12, %xmm6 # xmm6 = xmm6[0,0],xmm12[0,0]
mulps %xmm9, %xmm6
movaps %xmm12, %xmm5
unpckhpd %xmm12, %xmm5 # xmm5 = xmm5[1],xmm12[1]
mulss %xmm5, %xmm3
mulss %xmm15, %xmm5
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
addps %xmm6, %xmm5
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
addss %xmm6, %xmm3
movaps %xmm12, %xmm6
shufps $0xff, %xmm12, %xmm6 # xmm6 = xmm6[3,3],xmm12[3,3]
mulps %xmm6, %xmm8
mulss %xmm15, %xmm6
addss %xmm6, %xmm3
shufps $0x55, %xmm12, %xmm12 # xmm12 = xmm12[1,1,1,1]
movaps %xmm12, %xmm9
mulss %xmm15, %xmm9
addss %xmm3, %xmm9
addps %xmm5, %xmm8
shufps $0x55, %xmm5, %xmm5 # xmm5 = xmm5[1,1,1,1]
addss %xmm6, %xmm5
movaps %xmm10, %xmm6
addss %xmm12, %xmm5
mulps 0x29d680(%rip), %xmm12 # 0x55b3a0
addps %xmm8, %xmm12
movlhps %xmm14, %xmm6 # xmm6 = xmm6[0],xmm14[0]
shufps $0xd4, %xmm14, %xmm1 # xmm1 = xmm1[0,1],xmm14[1,3]
shufps $0x28, %xmm1, %xmm6 # xmm6 = xmm6[0,2],xmm1[2,0]
movlhps %xmm2, %xmm11 # xmm11 = xmm11[0],xmm2[0]
shufps $0xd4, %xmm2, %xmm4 # xmm4 = xmm4[0,1],xmm2[1,3]
shufps $0x28, %xmm4, %xmm11 # xmm11 = xmm11[0,2],xmm4[2,0]
movlhps %xmm13, %xmm7 # xmm7 = xmm7[0],xmm13[0]
shufps $0xd4, %xmm13, %xmm0 # xmm0 = xmm0[0,1],xmm13[1,3]
shufps $0x28, %xmm0, %xmm7 # xmm7 = xmm7[0,2],xmm0[2,0]
movlhps %xmm12, %xmm9 # xmm9 = xmm9[0],xmm12[0]
shufps $0xd4, %xmm12, %xmm5 # xmm5 = xmm5[0,1],xmm12[1,3]
shufps $0x28, %xmm5, %xmm9 # xmm9 = xmm9[0,2],xmm5[2,0]
movaps %xmm9, %xmm10
jmp 0x2be108
movss 0x30(%r15), %xmm1
mulss 0x2a2780(%rip), %xmm1 # 0x5604f0
divss 0x2d8dd8(%rip), %xmm1 # 0x596b50
movss %xmm1, 0x10(%rsp)
movss 0x24(%r15), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x28(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, %xmm0
callq 0x1a5c40
movaps %xmm0, 0x50(%rsp)
movss 0x10(%rsp), %xmm0
callq 0x1a50c0
movss 0x29d7fb(%rip), %xmm13 # 0x55b5b0
movaps 0x50(%rsp), %xmm10
subss %xmm10, %xmm13
movaps 0x40(%rsp), %xmm11
movaps %xmm11, %xmm5
mulss %xmm13, %xmm5
movaps %xmm5, %xmm1
mulss %xmm11, %xmm1
addss %xmm10, %xmm1
movaps 0x20(%rsp), %xmm4
movaps %xmm4, %xmm2
shufps $0x55, %xmm4, %xmm2 # xmm2 = xmm2[1,1],xmm4[1,1]
movaps %xmm5, %xmm7
movaps %xmm5, %xmm8
shufps $0x0, %xmm13, %xmm13 # xmm13 = xmm13[0,0,0,0]
mulps %xmm4, %xmm13
movaps %xmm13, %xmm9
mulss %xmm2, %xmm5
mulps %xmm2, %xmm13
mulss %xmm0, %xmm2
mulss %xmm4, %xmm8
addss %xmm2, %xmm8
movaps 0x29d487(%rip), %xmm6 # 0x55b2a0
xorps %xmm6, %xmm2
movaps %xmm4, %xmm3
mulss %xmm0, %xmm3
shufps $0x0, %xmm7, %xmm7 # xmm7 = xmm7[0,0,0,0]
unpcklps %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
mulps %xmm4, %xmm7
addps %xmm2, %xmm7
movaps %xmm7, 0x30(%rsp)
movaps %xmm11, %xmm2
mulss %xmm0, %xmm2
movaps %xmm2, %xmm0
xorps %xmm6, %xmm0
shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0]
unpcklps %xmm10, %xmm2 # xmm2 = xmm2[0],xmm10[0],xmm2[1],xmm10[1]
unpcklps %xmm0, %xmm10 # xmm10 = xmm10[0],xmm0[0],xmm10[1],xmm0[1]
mulps %xmm4, %xmm9
addps %xmm10, %xmm9
movaps %xmm9, %xmm11
movaps %xmm9, 0x20(%rsp)
subss %xmm3, %xmm5
addps %xmm2, %xmm13
movss (%rbx), %xmm0
movss 0x4(%rbx), %xmm2
movaps %xmm8, %xmm3
mulss %xmm2, %xmm3
movaps %xmm1, %xmm6
movaps %xmm1, 0x10(%rsp)
mulss %xmm0, %xmm6
addss %xmm3, %xmm6
movss 0x8(%rbx), %xmm4
movaps %xmm5, %xmm15
mulss %xmm4, %xmm15
addss %xmm6, %xmm15
movss 0xc(%rbx), %xmm9
movaps %xmm2, %xmm3
movaps %xmm0, %xmm10
movaps %xmm4, %xmm6
xorps %xmm12, %xmm12
mulss %xmm12, %xmm2
mulss %xmm12, %xmm0
addss %xmm2, %xmm0
mulss %xmm12, %xmm4
addss %xmm0, %xmm4
addss %xmm9, %xmm4
movaps %xmm4, 0x40(%rsp)
mulss %xmm12, %xmm9
addss %xmm9, %xmm15
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm11, %xmm3
shufps $0x0, %xmm10, %xmm10 # xmm10 = xmm10[0,0,0,0]
mulps %xmm7, %xmm10
addps %xmm3, %xmm10
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm13, %xmm6
addps %xmm10, %xmm6
shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0]
addps %xmm6, %xmm9
movss 0x10(%rbx), %xmm0
movss 0x14(%rbx), %xmm2
movaps %xmm8, %xmm3
mulss %xmm2, %xmm3
movaps %xmm1, %xmm7
mulss %xmm0, %xmm7
addss %xmm3, %xmm7
movss 0x18(%rbx), %xmm10
movaps %xmm5, %xmm11
mulss %xmm10, %xmm11
addss %xmm7, %xmm11
movss 0x1c(%rbx), %xmm4
movaps %xmm2, %xmm6
movaps %xmm0, %xmm12
xorps %xmm7, %xmm7
mulss %xmm7, %xmm2
mulss %xmm7, %xmm0
addss %xmm2, %xmm0
movaps %xmm10, %xmm3
mulss %xmm7, %xmm10
addss %xmm0, %xmm10
addss %xmm4, %xmm10
mulss %xmm7, %xmm4
addss %xmm4, %xmm11
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
movaps 0x20(%rsp), %xmm1
mulps %xmm1, %xmm6
shufps $0x0, %xmm12, %xmm12 # xmm12 = xmm12[0,0,0,0]
movaps 0x30(%rsp), %xmm2
mulps %xmm2, %xmm12
addps %xmm6, %xmm12
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm13, %xmm3
addps %xmm12, %xmm3
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
addps %xmm3, %xmm4
movss 0x20(%rbx), %xmm14
movss 0x24(%rbx), %xmm6
movaps %xmm8, %xmm0
mulss %xmm6, %xmm0
movaps 0x10(%rsp), %xmm3
mulss %xmm14, %xmm3
addss %xmm0, %xmm3
movss 0x28(%rbx), %xmm12
movaps %xmm5, %xmm7
mulss %xmm12, %xmm7
addss %xmm3, %xmm7
movaps %xmm6, %xmm0
shufps $0x0, %xmm6, %xmm0 # xmm0 = xmm0[0,0],xmm6[0,0]
mulps %xmm1, %xmm0
movaps %xmm14, %xmm3
shufps $0x0, %xmm14, %xmm3 # xmm3 = xmm3[0,0],xmm14[0,0]
mulps %xmm2, %xmm3
addps %xmm0, %xmm3
movaps %xmm12, %xmm0
shufps $0x0, %xmm12, %xmm0 # xmm0 = xmm0[0,0],xmm12[0,0]
mulps %xmm13, %xmm0
addps %xmm3, %xmm0
xorps %xmm1, %xmm1
mulss %xmm1, %xmm6
mulss %xmm1, %xmm14
addss %xmm6, %xmm14
movaps %xmm15, %xmm6
mulss %xmm1, %xmm12
addss %xmm14, %xmm12
movss 0x2c(%rbx), %xmm14
addss %xmm14, %xmm12
mulss %xmm1, %xmm14
xorps %xmm2, %xmm2
addss %xmm14, %xmm7
shufps $0x0, %xmm14, %xmm14 # xmm14 = xmm14[0,0,0,0]
addps %xmm0, %xmm14
movss 0x34(%rbx), %xmm3
mulss %xmm3, %xmm8
movss 0x30(%rbx), %xmm15
movaps 0x10(%rsp), %xmm0
mulss %xmm15, %xmm0
addss %xmm8, %xmm0
movss 0x38(%rbx), %xmm8
mulss %xmm8, %xmm5
addss %xmm0, %xmm5
movaps %xmm3, %xmm0
shufps $0x0, %xmm3, %xmm0 # xmm0 = xmm0[0,0],xmm3[0,0]
mulps 0x20(%rsp), %xmm0
movaps %xmm15, %xmm1
shufps $0x0, %xmm15, %xmm1 # xmm1 = xmm1[0,0],xmm15[0,0]
mulps 0x30(%rsp), %xmm1
addps %xmm0, %xmm1
movaps %xmm8, %xmm0
shufps $0x0, %xmm8, %xmm0 # xmm0 = xmm0[0,0],xmm8[0,0]
mulps %xmm13, %xmm0
addps %xmm1, %xmm0
mulss %xmm2, %xmm3
mulss %xmm2, %xmm15
addss %xmm3, %xmm15
mulss %xmm2, %xmm8
addss %xmm15, %xmm8
movss 0x3c(%rbx), %xmm1
addss %xmm1, %xmm8
mulss %xmm2, %xmm1
addss %xmm1, %xmm5
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
addps %xmm0, %xmm1
movlhps %xmm9, %xmm6 # xmm6 = xmm6[0],xmm9[0]
movaps 0x40(%rsp), %xmm0
shufps $0xd4, %xmm9, %xmm0 # xmm0 = xmm0[0,1],xmm9[1,3]
shufps $0x28, %xmm0, %xmm6 # xmm6 = xmm6[0,2],xmm0[2,0]
movlhps %xmm4, %xmm11 # xmm11 = xmm11[0],xmm4[0]
shufps $0xd4, %xmm4, %xmm10 # xmm10 = xmm10[0,1],xmm4[1,3]
shufps $0x28, %xmm10, %xmm11 # xmm11 = xmm11[0,2],xmm10[2,0]
movaps %xmm5, %xmm10
movlhps %xmm14, %xmm7 # xmm7 = xmm7[0],xmm14[0]
shufps $0xd4, %xmm14, %xmm12 # xmm12 = xmm12[0,1],xmm14[1,3]
shufps $0x28, %xmm12, %xmm7 # xmm7 = xmm7[0,2],xmm12[2,0]
movlhps %xmm1, %xmm10 # xmm10 = xmm10[0],xmm1[0]
shufps $0xd4, %xmm1, %xmm8 # xmm8 = xmm8[0,1],xmm1[1,3]
shufps $0x28, %xmm8, %xmm10 # xmm10 = xmm10[0,2],xmm8[2,0]
movups %xmm6, (%rbx)
movups %xmm11, 0x10(%rbx)
movups %xmm7, 0x20(%rbx)
movups %xmm10, 0x30(%rbx)
addq $0x68, %r15
movaps %xmm11, %xmm5
shufps $0x11, %xmm7, %xmm5 # xmm5 = xmm5[1,0],xmm7[1,0]
shufps $0x8d, %xmm10, %xmm10 # xmm10 = xmm10[1,3,0,2]
movaps %xmm7, %xmm0
shufps $0x30, %xmm11, %xmm0 # xmm0 = xmm0[0,0],xmm11[3,0]
movaps %xmm6, %xmm1
shufps $0xc7, %xmm11, %xmm1 # xmm1 = xmm1[3,1],xmm11[0,3]
shufps $0x28, %xmm1, %xmm0 # xmm0 = xmm0[0,2],xmm1[2,0]
movaps %xmm6, %xmm1
shufps $0x31, %xmm7, %xmm1 # xmm1 = xmm1[1,0],xmm7[3,0]
shufps $0x82, %xmm1, %xmm5 # xmm5 = xmm5[2,0],xmm1[0,2]
shufps $0x2, %xmm6, %xmm7 # xmm7 = xmm7[2,0],xmm6[0,0]
unpckhpd %xmm6, %xmm11 # xmm11 = xmm11[1],xmm6[1]
shufps $0x82, %xmm11, %xmm7 # xmm7 = xmm7[2,0],xmm11[0,2]
cmpq 0x8(%r14), %r15
jne 0x2bd2f2
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x29f903(%rip), %rdi # 0x55da7d
leaq 0x2de6de(%rip), %rsi # 0x59c85f
leaq 0x2deff4(%rip), %rcx # 0x59d17c
movl $0xd23, %edx # imm = 0xD23
callq 0x1a5270
leaq 0x29f8e4(%rip), %rdi # 0x55da7d
leaq 0x2de6bf(%rip), %rsi # 0x59c85f
leaq 0x2defd5(%rip), %rcx # 0x59d17c
movl $0xd2d, %edx # imm = 0xD2D
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaParser.cpp |
Assimp::Collada::Node::~Node() | ~Node() {
for( std::vector<Node*>::iterator it = mChildren.begin(); it != mChildren.end(); ++it)
delete *it;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %r15
cmpq 0x70(%rdi), %r15
je 0x2be33f
movq (%r15), %r14
testq %r14, %r14
je 0x2be328
movq %r14, %rdi
callq 0x2be306
movl $0x118, %esi # imm = 0x118
movq %r14, %rdi
callq 0x1a5190
addq $0x8, %r15
cmpq 0x70(%rbx), %r15
jne 0x2be318
movq 0xf8(%rbx), %rdi
leaq 0x108(%rbx), %rax
cmpq %rax, %rdi
je 0x2be35d
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
leaq 0xe0(%rbx), %rdi
callq 0x2c03ea
leaq 0xc8(%rbx), %rdi
callq 0x2c0448
leaq 0xb0(%rbx), %rdi
callq 0x2c04a6
leaq 0x98(%rbx), %rdi
callq 0x2c0504
leaq 0x80(%rbx), %rdi
callq 0x2acfe8
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x2be3ae
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2be3c6
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x2be3de
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2be3fa
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1a5190
popq %rbx
popq %r14
popq %r15
retq
| /hbina[P]fatuous/thirdparty/assimp/code/Collada/ColladaHelper.h |
Assimp::DXFImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void DXFImporter::InternReadFile( const std::string& filename, aiScene* pScene, IOSystem* pIOHandler) {
std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( filename) );
// Check whether we can read the file
if( file.get() == nullptr ) {
throw DeadlyImportError( "Failed to open DXF file " + filename + "");
}
// Check whether this is a binary DXF file - we can't read binary DXF files :-(
char buff[AI_DXF_BINARY_IDENT_LEN+1] = {0};
file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1);
if (0 == strncmp(AI_DXF_BINARY_IDENT.c_str(),buff,AI_DXF_BINARY_IDENT_LEN)) {
throw DeadlyImportError("DXF: Binary files are not supported at the moment");
}
// DXF files can grow very large, so read them via the StreamReader,
// which will choose a suitable strategy.
file->Seek(0,aiOrigin_SET);
StreamReaderLE stream( file );
DXF::LineReader reader (stream);
DXF::FileData output;
// now get all lines of the file and process top-level sections
bool eof = false;
while(!reader.End()) {
// blocks table - these 'build blocks' are later (in ENTITIES)
// referenced an included via INSERT statements.
if (reader.Is(2,"BLOCKS")) {
ParseBlocks(reader,output);
continue;
}
// primary entity table
if (reader.Is(2,"ENTITIES")) {
ParseEntities(reader,output);
continue;
}
// skip unneeded sections entirely to avoid any problems with them
// altogether.
else if (reader.Is(2,"CLASSES") || reader.Is(2,"TABLES")) {
SkipSection(reader);
continue;
}
else if (reader.Is(2,"HEADER")) {
ParseHeader(reader,output);
continue;
}
// comments
else if (reader.Is(999)) {
ASSIMP_LOG_INFO_F("DXF Comment: ", reader.Value());
}
// don't read past the official EOF sign
else if (reader.Is(0,"EOF")) {
eof = true;
break;
}
++reader;
}
if (!eof) {
ASSIMP_LOG_WARN("DXF: EOF reached, but did not encounter DXF EOF marker");
}
ConvertMeshes(pScene,output);
// Now rotate the whole scene by 90 degrees around the x axis to convert from AutoCAD's to Assimp's coordinate system
pScene->mRootNode->mTransformation = aiMatrix4x4(
1.f,0.f,0.f,0.f,
0.f,0.f,1.f,0.f,
0.f,-1.f,0.f,0.f,
0.f,0.f,0.f,1.f) * pScene->mRootNode->mTransformation;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x140(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2e2db0(%rip), %rsi # 0x5aa761
leaq 0x2e2dab(%rip), %rdx # 0x5aa763
leaq 0x130(%rsp), %rdi
callq 0x209290
movq (%rbx), %rsi
movq 0x130(%rsp), %rdx
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
leaq 0x10(%rsp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x2803c0
movq 0x130(%rsp), %rdi
cmpq %r12, %rdi
je 0x2c7a07
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2c7dae
xorps %xmm0, %xmm0
leaq 0xd0(%rsp), %rsi
movups %xmm0, 0x9(%rsi)
movaps %xmm0, (%rsi)
movq (%rdi), %rax
movl $0x18, %edx
movl $0x1, %ecx
callq *0x10(%rax)
movq 0x513a22(%rip), %rdi # 0x7db460
leaq 0xd0(%rsp), %rsi
movl $0x18, %edx
callq 0x1a53a0
testl %eax, %eax
je 0x2c7e01
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x2c7a95
movq 0x4e4521(%rip), %rcx # 0x7abfa8
cmpb $0x0, (%rcx)
je 0x2c7a91
incl 0x8(%rax)
jmp 0x2c7a95
lock
incl 0x8(%rax)
leaq 0xf8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x2cabc6
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2c7ab8
callq 0x280464
leaq 0x68(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x2cac46
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
cmpl $0x1, 0xc8(%rsp)
jle 0x2c7c03
callq 0x241234
leaq 0x2d5ad5(%rip), %rsi # 0x59d5ca
movq %rax, %rdi
callq 0x241182
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0x2c8512
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
xorps %xmm2, %xmm2
movups 0x404(%rax), %xmm5
movups 0x414(%rax), %xmm6
movups 0x424(%rax), %xmm3
movups 0x434(%rax), %xmm0
movaps %xmm5, %xmm1
mulps %xmm2, %xmm1
movaps %xmm1, %xmm4
subps %xmm6, %xmm1
mulps %xmm2, %xmm6
addps %xmm6, %xmm4
movaps %xmm3, %xmm7
mulps %xmm2, %xmm7
addps %xmm5, %xmm6
addps %xmm7, %xmm6
addps %xmm7, %xmm1
addps %xmm4, %xmm7
addps %xmm0, %xmm7
mulps %xmm2, %xmm0
addps %xmm0, %xmm6
movups %xmm6, 0x404(%rax)
addps %xmm3, %xmm4
addps %xmm0, %xmm4
movups %xmm4, 0x414(%rax)
addps %xmm0, %xmm1
movups %xmm1, 0x424(%rax)
movups %xmm7, 0x434(%rax)
leaq 0x30(%rsp), %rdi
callq 0x2cb5a0
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c7bb4
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c7bd5
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0xf8(%rsp), %rdi
callq 0x27f664
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2c7bf1
callq 0x280464
addq $0x2a8, %rsp # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68(%rsp), %rbp
leaq 0x130(%rsp), %rbx
movq 0x4e4379(%rip), %r13 # 0x7abf90
leaq 0x2d5c0a(%rip), %r15 # 0x59d828
movl 0xa0(%rsp), %eax
testl %eax, %eax
je 0x2c7d49
cmpl $0x3e7, %eax # imm = 0x3E7
je 0x2c7cc5
cmpl $0x2, %eax
jne 0x2c7d65
movq 0xa8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2c7d80
leaq 0x2d5c52(%rip), %rdi # 0x59d8b5
movq %r12, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2c7d9c
leaq 0x2d5933(%rip), %rdi # 0x59d5ad
movq %r12, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2c7d92
leaq 0x2d5924(%rip), %rdi # 0x59d5b5
movq %r12, %rsi
callq 0x1a5f30
testl %eax, %eax
je 0x2c7d92
leaq 0x2d58ac(%rip), %rdi # 0x59d554
movq %r12, %rsi
callq 0x1a5f30
testl %eax, %eax
jne 0x2c7d65
movq %rbp, %rsi
callq 0x2c84d2
jmp 0x2c7d6d
callq 0x241234
movq %rax, %r12
movq %rbx, %rdi
leaq 0x2d58e5(%rip), %rsi # 0x59d5bc
callq 0x2cacca
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a61e0
leaq 0x48(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x1a5690
movq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x24114a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2c7d2f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1a5d00
leaq 0x1a0(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2c7d65
movq 0xa8(%rsp), %rsi
leaq 0x2dac62(%rip), %rdi # 0x5a29ba
callq 0x1a5f30
testl %eax, %eax
je 0x2c7afd
movq %rbp, %rdi
callq 0x2cad1e
cmpl $0x2, 0xc8(%rsp)
jl 0x2c7c1e
jmp 0x2c7ae9
movq %r14, %rdi
movq %rbp, %rsi
leaq 0x30(%rsp), %rdx
callq 0x2c8032
jmp 0x2c7d6d
movq %rbp, %rsi
callq 0x2c8492
jmp 0x2c7d6d
movq %r14, %rdi
movq %rbp, %rsi
leaq 0x30(%rsp), %rdx
callq 0x2c81be
jmp 0x2c7d6d
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x2d57a0(%rip), %rsi # 0x59d562
leaq 0x68(%rsp), %rdi
movq %rbx, %rdx
callq 0x23ca59
leaq 0x2e0d6b(%rip), %rsi # 0x5a8b41
leaq 0x68(%rsp), %rdi
callq 0x1a5ba0
movq %r12, 0x130(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2c7e63
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x2c7e76
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x130(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x2d575b(%rip), %rsi # 0x59d57b
leaq 0x2d5785(%rip), %rdx # 0x59d5ac
callq 0x209290
movb $0x1, %bpl
leaq 0x130(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x4158f2(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x4158be(%rip), %rsi # 0x6dd710
movq 0x4e4107(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2c7ec2
movq %rdx, 0x130(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x140(%rsp)
movq 0x8(%rax), %rdx
leaq 0x130(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x1a53e0
leaq 0x415891(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x41585d(%rip), %rsi # 0x6dd710
movq 0x4e40a6(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
movq %rax, %rbx
movq 0x130(%rsp), %rdi
cmpq %r12, %rdi
je 0x2c7ee2
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c7f37
movq 0x78(%rsp), %rsi
jmp 0x2c7f2f
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c7f46
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2c7f46
movq %rax, %rbx
movq 0x130(%rsp), %rdi
cmpq %r12, %rdi
je 0x2c7f37
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2c7f46
jmp 0x2c801b
jmp 0x2c7f43
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x2c801b
movq %rax, %rbx
jmp 0x2c800e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2c801b
callq 0x280464
jmp 0x2c801b
movq %rax, %rbx
jmp 0x2c802a
movq %rax, %rbx
jmp 0x2c801b
movq %rax, %rbx
movq 0x130(%rsp), %rdi
cmpq %r12, %rdi
je 0x2c802a
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2c802a
jmp 0x2c7ff7
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2c7fd4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2c7fd4
jmp 0x2c7ff7
movq %rax, %rbx
movq 0x4e3fb5(%rip), %rsi # 0x7abf90
leaq 0x130(%rsp), %rdi
callq 0x1a5d00
leaq 0x1a0(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2c7ffa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2cb5a0
leaq 0x68(%rsp), %rdi
callq 0x2caf90
leaq 0xf8(%rsp), %rdi
callq 0x27f664
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2c802a
callq 0x280464
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/DXF/DXFLoader.cpp |
Assimp::DXFImporter::ExpandBlockReferences(Assimp::DXF::Block&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Assimp::DXF::Block const*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Assimp::DXF::Block const*>>> const&) | void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name) {
for (const DXF::InsertBlock& insert : bl.insertions) {
// first check if the referenced blocks exists ...
const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name);
if (it == blocks_by_name.end()) {
ASSIMP_LOG_ERROR_F("DXF: Failed to resolve block reference: ", insert.name,"; skipping" );
continue;
}
// XXX this would be the place to implement recursive expansion if needed.
const DXF::Block& bl_src = *(*it).second;
for (std::shared_ptr<const DXF::PolyLine> pl_in : bl_src.lines) {
std::shared_ptr<DXF::PolyLine> pl_out = std::shared_ptr<DXF::PolyLine>(new DXF::PolyLine(*pl_in));
if (bl_src.base.Length() || insert.scale.x!=1.f || insert.scale.y!=1.f || insert.scale.z!=1.f || insert.angle || insert.pos.Length()) {
// manual coordinate system transformation
// XXX order
aiMatrix4x4 trafo, tmp;
aiMatrix4x4::Translation(-bl_src.base,trafo);
trafo *= aiMatrix4x4::Scaling(insert.scale,tmp);
trafo *= aiMatrix4x4::Translation(insert.pos,tmp);
// XXX rotation currently ignored - I didn't find an appropriate sample model.
if (insert.angle != 0.f) {
ASSIMP_LOG_WARN("DXF: BLOCK rotation not currently implemented");
}
for (aiVector3D& v : pl_out->positions) {
v *= trafo;
}
}
bl.lines.push_back(pl_out);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdx, 0x8(%rsp)
movq 0x18(%rsi), %r12
movq %rsi, 0x40(%rsp)
movq 0x20(%rsi), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %r12
je 0x2c94f5
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
leaq 0x20(%r12), %rsi
movq 0x8(%rsp), %rdi
callq 0x2cc392
cmpq 0x30(%rsp), %rax
je 0x2c9440
movq 0x40(%rax), %rbx
movq (%rbx), %r15
movq 0x8(%rbx), %rax
movq %rax, 0x48(%rsp)
cmpq %rax, %r15
je 0x2c94e6
movq (%r15), %r14
movq 0x8(%r15), %r13
testq %r13, %r13
je 0x2c9075
movq 0x4e2f43(%rip), %rax # 0x7abfa8
cmpb $0x0, (%rax)
je 0x2c9070
incl 0x8(%r13)
jmp 0x2c9075
lock
incl 0x8(%r13)
movl $0xa8, %edi
callq 0x1a5230
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
callq 0x2cb194
movq %rbp, 0xc0(%rsp)
leaq 0xc8(%rsp), %rdi
movq %rbp, %rsi
callq 0x2cc41c
movsd 0x50(%rbx), %xmm1
movaps %xmm1, %xmm0
mulps %xmm1, %xmm0
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, 0xa0(%rsp)
mulss %xmm1, %xmm1
addss %xmm0, %xmm1
movss 0x58(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
sqrtss %xmm0, %xmm1
movsd 0xc(%r12), %xmm2
movss 0x14(%r12), %xmm3
movlhps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
movaps %xmm3, %xmm0
movaps %xmm2, 0xb0(%rsp)
shufps $0xd4, %xmm2, %xmm0 # xmm0 = xmm0[0,1],xmm2[1,3]
shufps $0x28, %xmm0, %xmm1 # xmm1 = xmm1[0,2],xmm0[2,0]
movss 0x18(%r12), %xmm0
cmpneqps 0x2d421d(%rip), %xmm1 # 0x59d330
movmskps %xmm1, %eax
movss (%r12), %xmm1
movaps %xmm1, 0x70(%rsp)
movss 0x4(%r12), %xmm1
movaps %xmm1, 0x20(%rsp)
movss 0x8(%r12), %xmm1
movaps %xmm1, 0x80(%rsp)
testl %eax, %eax
jne 0x2c9184
ucomiss 0x2924f1(%rip), %xmm0 # 0x55b638
jne 0x2c9184
jp 0x2c9184
movaps 0x20(%rsp), %xmm1
mulss %xmm1, %xmm1
movaps 0x70(%rsp), %xmm2
mulss %xmm2, %xmm2
addss %xmm1, %xmm2
movaps 0x80(%rsp), %xmm1
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
sqrtss %xmm1, %xmm1
ucomiss 0x2924bc(%rip), %xmm1 # 0x55b638
jne 0x2c9184
jnp 0x2c93fb
movaps %xmm3, 0x10(%rsp)
ucomiss 0x2924a8(%rip), %xmm0 # 0x55b638
jne 0x2c9194
jnp 0x2c91a8
callq 0x241234
movq %rax, %rdi
leaq 0x2d4630(%rip), %rsi # 0x59d7d3
callq 0x241182
movq 0xc0(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
movaps 0x10(%rsp), %xmm13
je 0x2c93fb
movaps 0x90(%rsp), %xmm3
movaps %xmm3, %xmm1
movaps 0x2920c8(%rip), %xmm0 # 0x55b2a0
xorps %xmm0, %xmm1
movaps 0xb0(%rsp), %xmm14
movaps %xmm14, %xmm5
shufps $0x55, %xmm14, %xmm5 # xmm5 = xmm5[1,1],xmm14[1,1]
xorps %xmm11, %xmm11
mulss %xmm11, %xmm5
movaps %xmm13, %xmm6
mulss %xmm11, %xmm6
addss %xmm11, %xmm6
xorps %xmm4, %xmm4
movaps 0xa0(%rsp), %xmm7
subps %xmm7, %xmm4
xorps %xmm0, %xmm7
movaps %xmm14, %xmm0
mulss %xmm11, %xmm0
addss %xmm11, %xmm0
addss %xmm11, %xmm13
mulss %xmm11, %xmm1
addss %xmm1, %xmm13
xorps %xmm2, %xmm2
subss %xmm3, %xmm2
movss %xmm2, 0x10(%rsp)
movlhps %xmm14, %xmm0 # xmm0 = xmm0[0],xmm14[0]
shufps $0xe2, %xmm14, %xmm0 # xmm0 = xmm0[2,0],xmm14[2,3]
xorps %xmm12, %xmm12
addps %xmm12, %xmm0
mulps %xmm12, %xmm7
movaps %xmm7, %xmm3
addps %xmm0, %xmm3
movss %xmm5, %xmm14 # xmm14 = xmm5[0],xmm14[1,2,3]
addps %xmm12, %xmm14
movaps %xmm7, %xmm5
addps %xmm14, %xmm5
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
addps %xmm7, %xmm6
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
addss %xmm1, %xmm0
addss %xmm1, %xmm14
movaps %xmm3, %xmm1
mulps %xmm12, %xmm1
addps %xmm5, %xmm1
movaps 0x20(%rsp), %xmm8
shufps $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0]
mulps %xmm5, %xmm8
mulps %xmm12, %xmm5
movaps %xmm3, %xmm9
movaps %xmm3, %xmm7
movaps 0x70(%rsp), %xmm2
movaps %xmm2, %xmm10
shufps $0x0, %xmm2, %xmm10 # xmm10 = xmm10[0,0],xmm2[0,0]
mulps %xmm3, %xmm10
addps %xmm5, %xmm3
mulss %xmm11, %xmm9
addss %xmm5, %xmm9
shufps $0x55, %xmm7, %xmm7 # xmm7 = xmm7[1,1,1,1]
shufps $0x55, %xmm5, %xmm5 # xmm5 = xmm5[1,1,1,1]
mulss %xmm11, %xmm7
addss %xmm5, %xmm7
movlhps %xmm6, %xmm7 # xmm7 = xmm7[0],xmm6[0]
shufps $0xe2, %xmm6, %xmm7 # xmm7 = xmm7[2,0],xmm6[2,3]
movaps %xmm6, %xmm5
mulps %xmm12, %xmm5
addps %xmm5, %xmm3
addps %xmm5, %xmm1
movaps 0x80(%rsp), %xmm15
movaps %xmm15, %xmm5
shufps $0x0, %xmm15, %xmm5 # xmm5 = xmm5[0,0],xmm15[0,0]
mulps %xmm6, %xmm5
movss %xmm9, %xmm6 # xmm6 = xmm9[0],xmm6[1,2,3]
addps %xmm6, %xmm7
addps %xmm8, %xmm10
addps %xmm10, %xmm5
addps %xmm4, %xmm5
mulps %xmm12, %xmm4
addps %xmm4, %xmm3
addps %xmm4, %xmm1
addps %xmm7, %xmm4
movaps %xmm14, %xmm8
mulss %xmm11, %xmm8
movaps %xmm0, %xmm6
addss %xmm8, %xmm6
movaps %xmm13, %xmm9
mulss %xmm11, %xmm9
addss %xmm9, %xmm6
mulss %xmm0, %xmm2
mulss %xmm11, %xmm0
movaps %xmm0, %xmm7
addss %xmm14, %xmm7
addss %xmm9, %xmm7
addss %xmm8, %xmm0
mulss 0x20(%rsp), %xmm14
addss %xmm2, %xmm14
addss %xmm13, %xmm0
mulss %xmm15, %xmm13
addss %xmm14, %xmm13
movss 0x10(%rsp), %xmm2
addss %xmm2, %xmm13
mulss %xmm11, %xmm2
addss %xmm2, %xmm6
addss %xmm2, %xmm7
addss %xmm2, %xmm0
movss (%rax), %xmm2
movss 0x4(%rax), %xmm8
movss 0x8(%rax), %xmm9
movaps %xmm7, %xmm10
mulss %xmm8, %xmm10
unpcklps %xmm8, %xmm8 # xmm8 = xmm8[0,0,1,1]
mulps %xmm1, %xmm8
movaps %xmm6, %xmm11
mulss %xmm2, %xmm11
unpcklps %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1]
mulps %xmm3, %xmm2
addps %xmm8, %xmm2
movaps %xmm0, %xmm8
mulss %xmm9, %xmm8
unpcklps %xmm9, %xmm9 # xmm9 = xmm9[0,0,1,1]
mulps %xmm4, %xmm9
addps %xmm2, %xmm9
addps %xmm5, %xmm9
addss %xmm10, %xmm11
addss %xmm8, %xmm11
addss %xmm13, %xmm11
movlps %xmm9, (%rax)
movss %xmm11, 0x8(%rax)
addq $0xc, %rax
cmpq %rcx, %rax
jne 0x2c938c
movq 0x40(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x2cb2ce
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x2c941f
callq 0x280464
testq %r13, %r13
je 0x2c942c
movq %r13, %rdi
callq 0x280464
addq $0x10, %r15
cmpq 0x48(%rsp), %r15
jne 0x2c9052
jmp 0x2c94e6
callq 0x241234
movq %rax, %r13
leaq 0xc0(%rsp), %rbx
movq %rbx, %rdi
leaq 0x2d4350(%rip), %rsi # 0x59d7aa
callq 0x255190
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
movq %rbx, %rdi
callq 0x1a61e0
movl $0xa, %edx
leaq 0xc0(%rsp), %rdi
leaq 0x2d43f3(%rip), %rsi # 0x59d878
callq 0x1a61e0
leaq 0x50(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1a5690
movq 0x50(%rsp), %rsi
movq %r13, %rdi
callq 0x2411ba
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x2c94c5
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0xc0(%rsp), %rdi
movq 0x4e2abc(%rip), %rsi # 0x7abf90
callq 0x1a5d00
leaq 0x130(%rsp), %rdi
callq 0x1a5ca0
addq $0x40, %r12
cmpq 0x38(%rsp), %r12
jne 0x2c901f
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x2c952b
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2c952b
movq %rax, %rbx
movq 0x4e2a5e(%rip), %rsi # 0x7abf90
leaq 0xc0(%rsp), %rdi
callq 0x1a5d00
leaq 0x130(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2c9589
jmp 0x2c9562
movq %rax, %rbx
movl $0xa8, %esi
movq %rbp, %rdi
callq 0x1a5190
jmp 0x2c957c
movq %rax, %rbx
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x2c957c
callq 0x280464
jmp 0x2c957c
movq %rax, %rbx
testq %r13, %r13
je 0x2c9589
movq %r13, %rdi
callq 0x280464
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/DXF/DXFLoader.cpp |
Assimp::DXFImporter::GenerateMaterials(aiScene*, Assimp::DXF::FileData&) | void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/) {
// generate an almost-white default material. Reason:
// the default vertex color is GREY, so we are
// already at Assimp's usual default color.
// generate a default material
aiMaterial* pcMat = new aiMaterial();
aiString s;
s.Set(AI_DEFAULT_MATERIAL_NAME);
pcMat->AddProperty(&s, AI_MATKEY_NAME);
aiColor4D clrDiffuse(0.9f,0.9f,0.9f,1.0f);
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE);
clrDiffuse = aiColor4D(1.0f,1.0f,1.0f,1.0f);
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR);
clrDiffuse = aiColor4D(0.05f,0.05f,0.05f,1.0f);
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT);
pScene->mNumMaterials = 1;
pScene->mMaterials = new aiMaterial*[1];
pScene->mMaterials[0] = pcMat;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rsi, %r14
movl $0x10, %edi
callq 0x1a5230
movq %rax, %rbx
movq %rax, %rdi
callq 0x2466d0
leaq 0x38(%rsp), %r15
movl $0x3f0, %edx # imm = 0x3F0
movq %r15, %rdi
movl $0x1b, %esi
callq 0x1a54e0
movl $0xf, -0x14(%r15)
movabsq $0x4d746c7561666544, %rax # imm = 0x4D746C7561666544
movq %rax, -0x10(%r15)
movabsq $0x6c6169726574614d, %rax # imm = 0x6C6169726574614D
movq %rax, -0x9(%r15)
movb $0x0, -0x1(%r15)
leaq 0x2c61df(%rip), %rdx # 0x58f939
leaq 0x24(%rsp), %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x246b54
movaps 0x29941d(%rip), %xmm0 # 0x562b90
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movl $0x1, %ebp
movl %ebp, (%rsp)
leaq 0x2c6191(%rip), %rcx # 0x58f91c
movq %rbx, %rdi
movq %r15, %rsi
movl $0x10, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movaps 0x299188(%rip), %xmm0 # 0x562930
movaps %xmm0, (%r15)
movl %ebp, (%rsp)
leaq 0x2cee78(%rip), %rcx # 0x59862e
movq %rbx, %rdi
movq %r15, %rsi
movl $0x10, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movaps 0x2d3b6d(%rip), %xmm0 # 0x59d340
movaps %xmm0, (%r15)
movl %ebp, (%rsp)
leaq 0x2cc052(%rip), %rcx # 0x595833
movq %rbx, %rdi
movq %r15, %rsi
movl $0x10, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movl %ebp, 0x20(%r14)
movl $0x8, %edi
callq 0x1a57a0
movq %rax, 0x28(%r14)
movq %rbx, (%rax)
addq $0x428, %rsp # imm = 0x428
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1a5190
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/DXF/DXFLoader.cpp |
Assimp::DXF::LineReader::operator++() | LineReader& operator++() {
if (end) {
if (end == 1) {
++end;
}
return *this;
}
try {
groupcode = strtol10(splitter->c_str());
splitter++;
value = *splitter;
splitter++;
// automatically skip over {} meta blocks (these are for application use
// and currently not relevant for Assimp).
if (value.length() && value[0] == '{') {
size_t cnt = 0;
for(;splitter->length() && splitter->at(0) != '}'; splitter++, cnt++);
splitter++;
ASSIMP_LOG_DEBUG((Formatter::format("DXF: skipped over control group ("),cnt," lines)"));
}
} catch(std::logic_error&) {
ai_assert(!splitter);
}
if (!splitter) {
end = 1;
}
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movl 0x60(%rdi), %eax
cmpl $0x1, %eax
je 0x2cae28
testl %eax, %eax
jne 0x2caedf
movq 0x8(%rbx), %rsi
movb (%rsi), %al
leal -0x2b(%rax), %ecx
xorl %edi, %edi
testb $-0x3, %cl
sete %dil
movb (%rsi,%rdi), %cl
leal -0x3a(%rcx), %r8d
xorl %edx, %edx
cmpb $-0xa, %r8b
jb 0x2cad86
addq %rdi, %rsi
incq %rsi
xorl %edx, %edx
leal (%rdx,%rdx,4), %edx
addb $-0x30, %cl
movzbl %cl, %ecx
leal (%rcx,%rdx,2), %edx
movb (%rsi), %cl
leal -0x3a(%rcx), %edi
incq %rsi
cmpb $-0xb, %dil
ja 0x2cad6c
movl %edx, %ecx
negl %ecx
cmpb $0x2d, %al
cmovnel %edx, %ecx
movl %ecx, 0x38(%rbx)
movq %rbx, %rdi
callq 0x2cb430
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x20ac60
leaq 0x40(%rbx), %r14
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a58d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x2cade2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x2cb430
cmpq $0x0, 0x48(%rbx)
je 0x2caecb
movq (%r14), %rax
cmpb $0x7b, (%rax)
jne 0x2caecb
cmpq $0x0, 0x10(%rbx)
je 0x2cae32
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
cmpb $0x7d, (%rax)
je 0x2cae35
movq %rbx, %rdi
callq 0x2cb430
incq %r14
cmpq $0x0, 0x10(%rbx)
jne 0x2cae0b
jmp 0x2cae35
movl $0x2, %eax
jmp 0x2caedc
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2cb430
callq 0x241234
movq %rax, %r15
leaq 0x2d2c9c(%rip), %rsi # 0x59dae8
leaq 0x20(%rsp), %rdi
callq 0x248ec4
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x1a5850
leaq 0x2d2ca0(%rip), %rsi # 0x59db0a
leaq 0x20(%rsp), %rdi
movl $0x7, %edx
callq 0x1a61e0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x1a5690
movq (%rsp), %rsi
movq %r15, %rdi
callq 0x241112
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2caead
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x4e10dc(%rip), %rsi # 0x7abf90
leaq 0x20(%rsp), %rdi
callq 0x1a5d00
leaq 0x90(%rsp), %rdi
callq 0x1a5ca0
movq 0x28(%rbx), %rax
movl 0x20(%rax), %ecx
cmpl 0x18(%rax), %ecx
jne 0x2caedf
movl $0x1, %eax
movl %eax, 0x60(%rbx)
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2caf1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2caf1e
jmp 0x2caf42
jmp 0x2caf42
movq %rdx, %r15
movq %rax, %r14
movq 0x4e106b(%rip), %rsi # 0x7abf90
leaq 0x20(%rsp), %rdi
callq 0x1a5d00
leaq 0x90(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2caf48
jmp 0x2caf42
jmp 0x2caf42
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x2caf6c
callq 0x1a50d0
movq 0x28(%rbx), %rax
movl 0x20(%rax), %ecx
cmpl 0x18(%rax), %ecx
jne 0x2caf71
callq 0x1a5e20
jmp 0x2caecb
callq 0x1a5b90
leaq 0x2d2b9a(%rip), %rdi # 0x59db12
leaq 0x2d2b9d(%rip), %rsi # 0x59db1c
leaq 0x2d2c06(%rip), %rcx # 0x59db8c
movl $0x8d, %edx
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/assimp/code/DXF/DXFHelper.h |
Assimp::LWOImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void LWOImporter::InternReadFile( const std::string& pFile,
aiScene* pScene,
IOSystem* pIOHandler)
{
std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
// Check whether we can read from the file
if( file.get() == NULL)
throw DeadlyImportError( "Failed to open LWO file " + pFile + ".");
if((this->fileSize = (unsigned int)file->FileSize()) < 12)
throw DeadlyImportError("LWO: The file is too small to contain the IFF header");
// Allocate storage and copy the contents of the file to a memory buffer
std::vector< uint8_t > mBuffer(fileSize);
file->Read( &mBuffer[0], 1, fileSize);
this->pScene = pScene;
// Determine the type of the file
uint32_t fileType;
const char* sz = IFF::ReadHeader(&mBuffer[0],fileType);
if (sz)throw DeadlyImportError(sz);
mFileBuffer = &mBuffer[0] + 12;
fileSize -= 12;
// Initialize some members with their default values
hasNamedLayer = false;
// Create temporary storage on the stack but store pointers to it in the class
// instance. Therefore everything will be destructed properly if an exception
// is thrown and we needn't take care of that.
LayerList _mLayers;
SurfaceList _mSurfaces;
TagList _mTags;
TagMappingTable _mMapping;
mLayers = &_mLayers;
mTags = &_mTags;
mMapping = &_mMapping;
mSurfaces = &_mSurfaces;
// Allocate a default layer (layer indices are 1-based from now)
mLayers->push_back(Layer());
mCurLayer = &mLayers->back();
mCurLayer->mName = "<LWODefault>";
mCurLayer->mIndex = -1;
// old lightwave file format (prior to v6)
if (AI_LWO_FOURCC_LWOB == fileType) {
ASSIMP_LOG_INFO("LWO file format: LWOB (<= LightWave 5.5)");
mIsLWO2 = false;
mIsLXOB = false;
LoadLWOBFile();
}
// New lightwave format
else if (AI_LWO_FOURCC_LWO2 == fileType) {
mIsLXOB = false;
ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)");
}
// MODO file format
else if (AI_LWO_FOURCC_LXOB == fileType) {
mIsLXOB = true;
ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)");
}
// we don't know this format
else
{
char szBuff[5];
szBuff[0] = (char)(fileType >> 24u);
szBuff[1] = (char)(fileType >> 16u);
szBuff[2] = (char)(fileType >> 8u);
szBuff[3] = (char)(fileType);
szBuff[4] = '\0';
throw DeadlyImportError(std::string("Unknown LWO sub format: ") + szBuff);
}
if (AI_LWO_FOURCC_LWOB != fileType) {
mIsLWO2 = true;
LoadLWO2File();
// The newer lightwave format allows the user to configure the
// loader that just one layer is used. If this is the case
// we need to check now whether the requested layer has been found.
if (UINT_MAX != configLayerIndex) {
unsigned int layerCount = 0;
for(std::list<LWO::Layer>::iterator itLayers=mLayers->begin(); itLayers!=mLayers->end(); ++itLayers)
if (!itLayers->skip)
layerCount++;
if (layerCount!=2)
throw DeadlyImportError("LWO2: The requested layer was not found");
}
if (configLayerName.length() && !hasNamedLayer) {
throw DeadlyImportError("LWO2: Unable to find the requested layer: "
+ configLayerName);
}
}
// now, as we have loaded all data, we can resolve cross-referenced tags and clips
ResolveTags();
ResolveClips();
// now process all layers and build meshes and nodes
std::vector<aiMesh*> apcMeshes;
std::map<uint16_t, aiNode*> apcNodes;
apcMeshes.reserve(mLayers->size()*std::min(((unsigned int)mSurfaces->size()/2u), 1u));
unsigned int iDefaultSurface = UINT_MAX; // index of the default surface
for (LWO::Layer &layer : *mLayers) {
if (layer.skip)
continue;
// I don't know whether there could be dummy layers, but it would be possible
const unsigned int meshStart = (unsigned int)apcMeshes.size();
if (!layer.mFaces.empty() && !layer.mTempPoints.empty()) {
// now sort all faces by the surfaces assigned to them
std::vector<SortedRep> pSorted(mSurfaces->size()+1);
unsigned int i = 0;
for (FaceList::iterator it = layer.mFaces.begin(), end = layer.mFaces.end();it != end;++it,++i) {
// Check whether we support this face's type
if ((*it).type != AI_LWO_FACE && (*it).type != AI_LWO_PTCH &&
(*it).type != AI_LWO_BONE && (*it).type != AI_LWO_SUBD) {
continue;
}
unsigned int idx = (*it).surfaceIndex;
if (idx >= mTags->size())
{
ASSIMP_LOG_WARN("LWO: Invalid face surface index");
idx = UINT_MAX;
}
if(UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx])) {
if (UINT_MAX == iDefaultSurface) {
iDefaultSurface = (unsigned int)mSurfaces->size();
mSurfaces->push_back(LWO::Surface());
LWO::Surface& surf = mSurfaces->back();
surf.mColor.r = surf.mColor.g = surf.mColor.b = 0.6f;
surf.mName = "LWODefaultSurface";
}
idx = iDefaultSurface;
}
pSorted[idx].push_back(i);
}
if (UINT_MAX == iDefaultSurface) {
pSorted.erase(pSorted.end()-1);
}
for (unsigned int p = 0,i = 0;i < mSurfaces->size();++i) {
SortedRep& sorted = pSorted[i];
if (sorted.empty())
continue;
// generate the mesh
aiMesh* mesh = new aiMesh();
apcMeshes.push_back(mesh);
mesh->mNumFaces = (unsigned int)sorted.size();
// count the number of vertices
SortedRep::const_iterator it = sorted.begin(), end = sorted.end();
for (;it != end;++it) {
mesh->mNumVertices += layer.mFaces[*it].mNumIndices;
}
aiVector3D *nrm = NULL, * pv = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
aiFace* pf = mesh->mFaces = new aiFace[mesh->mNumFaces];
mesh->mMaterialIndex = i;
// find out which vertex color channels and which texture coordinate
// channels are really required by the material attached to this mesh
unsigned int vUVChannelIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS];
unsigned int vVColorIndices[AI_MAX_NUMBER_OF_COLOR_SETS];
#ifdef ASSIMP_BUILD_DEBUG
for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS;++mui ) {
vUVChannelIndices[mui] = UINT_MAX;
}
for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS;++mui ) {
vVColorIndices[mui] = UINT_MAX;
}
#endif
FindUVChannels(_mSurfaces[i],sorted,layer,vUVChannelIndices);
FindVCChannels(_mSurfaces[i],sorted,layer,vVColorIndices);
// allocate storage for UV and CV channels
aiVector3D* pvUV[AI_MAX_NUMBER_OF_TEXTURECOORDS];
for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS;++mui ) {
if (UINT_MAX == vUVChannelIndices[mui]) {
break;
}
pvUV[mui] = mesh->mTextureCoords[mui] = new aiVector3D[mesh->mNumVertices];
// LightWave doesn't support more than 2 UV components (?)
mesh->mNumUVComponents[0] = 2;
}
if (layer.mNormals.name.length())
nrm = mesh->mNormals = new aiVector3D[mesh->mNumVertices];
aiColor4D* pvVC[AI_MAX_NUMBER_OF_COLOR_SETS];
for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS;++mui) {
if (UINT_MAX == vVColorIndices[mui]) {
break;
}
pvVC[mui] = mesh->mColors[mui] = new aiColor4D[mesh->mNumVertices];
}
// we would not need this extra array, but the code is much cleaner if we use it
std::vector<unsigned int>& smoothingGroups = layer.mPointReferrers;
smoothingGroups.erase (smoothingGroups.begin(),smoothingGroups.end());
smoothingGroups.resize(mesh->mNumFaces,0);
// now convert all faces
unsigned int vert = 0;
std::vector<unsigned int>::iterator outIt = smoothingGroups.begin();
for (it = sorted.begin(); it != end;++it,++outIt) {
const LWO::Face& face = layer.mFaces[*it];
*outIt = face.smoothGroup;
// copy all vertices
for (unsigned int q = 0; q < face.mNumIndices;++q,++vert) {
unsigned int idx = face.mIndices[q];
*pv++ = layer.mTempPoints[idx] /*- layer.mPivot*/;
// process UV coordinates
for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_TEXTURECOORDS;++w) {
if (UINT_MAX == vUVChannelIndices[w]) {
break;
}
aiVector3D*& pp = pvUV[w];
const aiVector2D& src = ((aiVector2D*)&layer.mUVChannels[vUVChannelIndices[w]].rawData[0])[idx];
pp->x = src.x;
pp->y = src.y;
pp++;
}
// process normals (MODO extension)
if (nrm) {
*nrm = ((aiVector3D*)&layer.mNormals.rawData[0])[idx];
nrm->z *= -1.f;
++nrm;
}
// process vertex colors
for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_COLOR_SETS;++w) {
if (UINT_MAX == vVColorIndices[w]) {
break;
}
*pvVC[w] = ((aiColor4D*)&layer.mVColorChannels[vVColorIndices[w]].rawData[0])[idx];
// If a RGB color map is explicitly requested delete the
// alpha channel - it could theoretically be != 1.
if(_mSurfaces[i].mVCMapType == AI_LWO_RGB)
pvVC[w]->a = 1.f;
pvVC[w]++;
}
#if 0
// process vertex weights. We can't properly reconstruct the whole skeleton for now,
// but we can create dummy bones for all weight channels which we have.
for (unsigned int w = 0; w < layer.mWeightChannels.size();++w)
{
}
#endif
face.mIndices[q] = vert;
}
pf->mIndices = face.mIndices;
pf->mNumIndices = face.mNumIndices;
unsigned int** p = (unsigned int**)&face.mIndices;*p = NULL; // HACK: make sure it won't be deleted
pf++;
}
if (!mesh->mNormals) {
// Compute normal vectors for the mesh - we can't use our GenSmoothNormal-
// Step here since it wouldn't handle smoothing groups correctly for LWO.
// So we use a separate implementation.
ComputeNormals(mesh,smoothingGroups,_mSurfaces[i]);
}
else {
ASSIMP_LOG_DEBUG("LWO2: No need to compute normals, they're already there");
}
++p;
}
}
// Generate nodes to render the mesh. Store the source layer in the mParent member of the nodes
unsigned int num = static_cast<unsigned int>(apcMeshes.size() - meshStart);
if (layer.mName != "<LWODefault>" || num > 0) {
aiNode* pcNode = new aiNode();
pcNode->mName.Set(layer.mName);
pcNode->mParent = (aiNode*)&layer;
pcNode->mNumMeshes = num;
if (pcNode->mNumMeshes) {
pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
for (unsigned int p = 0; p < pcNode->mNumMeshes;++p)
pcNode->mMeshes[p] = p + meshStart;
}
apcNodes[layer.mIndex] = pcNode;
}
}
if (apcNodes.empty() || apcMeshes.empty())
throw DeadlyImportError("LWO: No meshes loaded");
// The RemoveRedundantMaterials step will clean this up later
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = (unsigned int)mSurfaces->size()];
for (unsigned int mat = 0; mat < pScene->mNumMaterials;++mat) {
aiMaterial* pcMat = new aiMaterial();
pScene->mMaterials[mat] = pcMat;
ConvertMaterial((*mSurfaces)[mat],pcMat);
}
// copy the meshes to the output structure
pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes = (unsigned int)apcMeshes.size() ];
::memcpy(pScene->mMeshes,&apcMeshes[0],pScene->mNumMeshes*sizeof(void*));
// generate the final node graph
GenerateNodeGraph(apcNodes);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp # imm = 0x358
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x1b0(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2d1d87(%rip), %rsi # 0x5aa761
leaq 0x2d1d82(%rip), %rdx # 0x5aa763
leaq 0x1a0(%rsp), %rdi
callq 0x209290
movq (%rbx), %rsi
movq 0x1a0(%rsp), %rdx
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, %r13
movq 0x1a0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d8a22
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testq %r13, %r13
je 0x2d999e
movq (%r13), %rax
movq %r13, %rdi
callq *0x30(%rax)
movl %eax, 0xe0(%r12)
cmpl $0xb, %eax
jbe 0x2d9a02
movl %eax, %esi
leaq 0xd8(%rsp), %rdi
leaq 0x1a0(%rsp), %rdx
callq 0x2de078
movq 0xd8(%rsp), %rsi
movl 0xe0(%r12), %ecx
movq (%r13), %rax
movl $0x1, %edx
movq %r13, %rdi
callq *0x10(%rax)
movq %r13, 0x8(%rsp)
movq %r15, 0x148(%rsp)
movq %r15, 0xe8(%r12)
movq 0xd8(%rsp), %rax
cmpl $0x4d524f46, (%rax) # imm = 0x4D524F46
jne 0x2d9a6a
movl 0x8(%rax), %r13d
addq $0xc, %rax
movq %rax, 0xd8(%r12)
addl $-0xc, 0xe0(%r12)
xorl %r15d, %r15d
movb %r15b, 0x118(%r12)
leaq 0x188(%rsp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq %r15, 0x10(%rbx)
leaq 0xa0(%rsp), %rax
movq %r15, 0x10(%rax)
pxor %xmm0, %xmm0
movdqa %xmm0, (%rax)
leaq 0x340(%rsp), %rcx
movq %r15, 0x10(%rcx)
movdqa %xmm0, (%rcx)
leaq 0x130(%rsp), %rdx
movq %r15, 0x10(%rdx)
movdqa %xmm0, (%rdx)
movq %rbx, 0x80(%r12)
movq %rcx, 0x90(%r12)
movq %rdx, 0x98(%r12)
movq %rax, 0xa0(%r12)
movq %r12, %rbp
leaq 0x248(%rsp), %r12
leaq 0x1a0(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1a54e0
movq %r12, -0x10(%r12)
movq %r15, -0x8(%r12)
movb %r15b, (%r12)
movl $0x3, 0x10(%r12)
movq %r15, 0x40(%r12)
movl %r15d, 0x48(%r12)
movq %r15, 0x50(%r12)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x18(%r12)
movdqu %xmm0, 0x28(%r12)
movl %r15d, 0x38(%r12)
leaq 0x406962(%rip), %rax # 0x6df4f8
movq %rax, -0x18(%r12)
movdqu %xmm0, 0x58(%r12)
movdqu %xmm0, 0x68(%r12)
movl $0xffff0000, 0x78(%r12) # imm = 0xFFFF0000
leaq 0x2d8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r15, -0x8(%rax)
movb %r15b, (%rax)
movq %r15, 0x15(%rax)
movq %r15, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2df38c
leaq 0x188(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1a5360
incq 0x10(%rbx)
leaq 0x1a0(%rsp), %rdi
callq 0x2de0d8
movq 0x80(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rax
movq %rax, 0x88(%rbp)
movq 0x140(%rdi), %rdx
addq $0x138, %rdi # imm = 0x138
leaq 0x2c6615(%rip), %rcx # 0x59f23c
movl $0xc, %r8d
xorl %esi, %esi
callq 0x1a5830
movq 0x88(%rbp), %rax
movw $0xffff, 0x122(%rax) # imm = 0xFFFF
movl %r13d, %ecx
bswapl %ecx
cmpl $0x4c574f32, %ecx # imm = 0x4C574F32
je 0x2d8c9e
cmpl $0x4c584f42, %ecx # imm = 0x4C584F42
je 0x2d8c8c
cmpl $0x4c574f42, %ecx # imm = 0x4C574F42
jne 0x2d9bc6
callq 0x241234
leaq 0x2c65d8(%rip), %rsi # 0x59f249
movq %rax, %rdi
callq 0x24114a
movw $0x0, 0x78(%rbp)
movq %rbp, %rdi
callq 0x52ef18
jmp 0x2d8d14
movb $0x1, 0x79(%rbp)
callq 0x241234
leaq 0x2c65fd(%rip), %rsi # 0x59f299
jmp 0x2d8cae
movb $0x0, 0x79(%rbp)
callq 0x241234
leaq 0x2c65c4(%rip), %rsi # 0x59f272
movq %rax, %rdi
callq 0x24114a
movb $0x1, 0x78(%rbp)
movq %rbp, %rdi
callq 0x2da09a
cmpl $-0x1, 0xf4(%rbp)
je 0x2d8cfd
movq 0x80(%rbp), %rax
movq (%rax), %rcx
cmpq %rax, %rcx
je 0x2d9adf
xorl %edx, %edx
movzbl 0x164(%rcx), %esi
xorl $0x1, %esi
addl %esi, %edx
movq (%rcx), %rcx
cmpq %rax, %rcx
jne 0x2d8ce0
cmpl $0x2, %edx
jne 0x2d9adf
cmpq $0x0, 0x100(%rbp)
je 0x2d8d14
cmpb $0x0, 0x118(%rbp)
je 0x2d9b54
movq %rbp, %rdi
callq 0x2da7f6
movq %rbp, %rdi
callq 0x2da956
pxor %xmm0, %xmm0
movdqa %xmm0, 0x30(%rsp)
xorl %esi, %esi
movq %rsi, 0x40(%rsp)
leaq 0x160(%rsp), %rax
movl $0x0, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rsi, 0x20(%rax)
movq 0xa0(%rbp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
imull $0xc18f9c19, %ecx, %eax # imm = 0xC18F9C19
testl $0xfffffffe, %eax # imm = 0xFFFFFFFE
je 0x2d8d7d
movq 0x80(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x30(%rsp), %rdi
callq 0x25bd7e
movq %rbp, 0x18(%rsp)
movq 0x80(%rbp), %r15
movq (%r15), %r12
cmpq %r15, %r12
je 0x2d9787
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movq %r15, 0x80(%rsp)
cmpb $0x0, 0x164(%r12)
jne 0x2d977a
leaq 0x10(%r12), %rax
movq %rax, 0x70(%rsp)
movq 0x38(%rsp), %rcx
subq 0x30(%rsp), %rcx
sarq $0x3, %rcx
movq 0x110(%r12), %rax
cmpq 0x118(%r12), %rax
movq %rcx, 0x88(%rsp)
je 0x2d96a2
movq 0x10(%r12), %rax
cmpq 0x18(%r12), %rax
je 0x2d96a2
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x3, %rsi
movabsq $-0x7063e7063e7063e7, %rax # imm = 0x8F9C18F9C18F9C19
imulq %rax, %rsi
incq %rsi
leaq 0xc0(%rsp), %rdi
leaq 0x1a0(%rsp), %rdx
callq 0x2de162
movl $0x0, 0x24(%rsp)
movq 0x110(%r12), %r14
movq 0x118(%r12), %r15
cmpq %r15, %r14
movl 0x54(%rsp), %ebx
je 0x2d8fdf
xorl %eax, %eax
movq %r15, 0x28(%rsp)
movl 0x18(%r14), %ecx
cmpl $0x50544347, %ecx # imm = 0x50544347
jg 0x2d8e93
cmpl $0x424f4e45, %ecx # imm = 0x424F4E45
je 0x2d8ea7
cmpl $0x46414345, %ecx # imm = 0x46414345
je 0x2d8ea7
jmp 0x2d8fcc
cmpl $0x53554244, %ecx # imm = 0x53554244
je 0x2d8ea7
cmpl $0x50544348, %ecx # imm = 0x50544348
jne 0x2d8fcc
movl 0x10(%r14), %eax
movq 0x18(%rsp), %rcx
movq 0x90(%rcx), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x5, %rdx
cmpq %rax, %rdx
jbe 0x2d8ee2
cmpl $-0x1, %eax
je 0x2d8ef6
movq 0x130(%rsp), %rcx
movl (%rcx,%rax,4), %eax
cmpl $-0x1, %eax
jne 0x2d8f95
jmp 0x2d8ef6
callq 0x241234
movq %rax, %rdi
leaq 0x2c6431(%rip), %rsi # 0x59f322
callq 0x241182
movl %ebx, %eax
cmpl $-0x1, %ebx
jne 0x2d8f95
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rbx
movq 0x8(%rbx), %r13
subq (%rbx), %r13
leaq 0x1a0(%rsp), %r15
movq %r15, %rdi
callq 0x2de1e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2df7b6
movq %r15, %rdi
callq 0x2de368
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq 0x8(%rax), %rax
leaq -0x148(%rax), %rdi
movl $0x3f19999a, -0x120(%rax) # imm = 0x3F19999A
movq 0x2b68b0(%rip), %xmm0 # 0x58f810
movq %xmm0, -0x128(%rax)
movq -0x140(%rax), %rdx
movl $0x11, %r8d
xorl %esi, %esi
leaq 0x2c63c4(%rip), %rcx # 0x59f342
callq 0x1a5830
shrq $0x3, %r13
imull $0xc18f9c19, %r13d, %eax # imm = 0xC18F9C19
movl %eax, %ebx
movq 0x28(%rsp), %r15
movl %eax, %eax
movq 0xc0(%rsp), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2d8fbe
movl 0x24(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, 0x8(%rdi)
jmp 0x2d8fcc
leaq 0x24(%rsp), %rdx
callq 0x21f20e
movl 0x24(%rsp), %eax
addq $0x20, %r14
incl %eax
movl %eax, 0x24(%rsp)
cmpq %r15, %r14
jne 0x2d8e72
movl %ebx, 0x54(%rsp)
cmpl $-0x1, %ebx
jne 0x2d9001
movq 0xc8(%rsp), %rsi
addq $-0x18, %rsi
leaq 0xc0(%rsp), %rdi
callq 0x2e03e6
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x2d9675
leaq 0x28(%r12), %rdx
movq %rdx, 0x60(%rsp)
xorl %ebx, %ebx
movq 0xc0(%rsp), %r15
leaq (%rbx,%rbx,2), %r13
movq (%r15,%r13,8), %rdx
cmpq 0x8(%r15,%r13,8), %rdx
je 0x2d9651
movq %rbx, 0x68(%rsp)
movl $0x520, %edi # imm = 0x520
callq 0x1a5230
movq %rax, %rbx
movq $0x0, (%rax)
xorl %eax, %eax
movl %eax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0xf1(%rbx), %r14
movl $0xcc, %edx
xorl %esi, %esi
callq 0x1a54e0
pxor %xmm0, %xmm0
movdqu %xmm0, 0xe0(%rbx)
movb $0x0, 0xf0(%rbx)
movl $0x3ff, %edx # imm = 0x3FF
movq %r14, %rdi
movl $0x1b, %esi
callq 0x1a54e0
xorl %eax, %eax
movl %eax, 0x4f0(%rbx)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x4f8(%rbx)
movdqu %xmm0, 0x508(%rbx)
movl %eax, 0x518(%rbx)
movq %rbx, %rdi
addq $0x30, %rdi
movl $0xa0, %edx
xorl %esi, %esi
callq 0x1a54e0
movq %rbx, 0x10(%rsp)
movq 0x38(%rsp), %rsi
cmpq 0x40(%rsp), %rsi
je 0x2d90ec
movq %rbx, (%rsi)
addq $0x8, 0x38(%rsp)
jmp 0x2d90fb
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x250da2
leaq (%r15,%r13,8), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x2, %rax
movq 0x10(%rsp), %r14
movl %eax, 0x8(%r14)
movq (%rcx), %rax
movq %rcx, 0x90(%rsp)
movq 0x8(%rcx), %r13
cmpq %r13, %rax
je 0x2d914e
movl (%rax), %ecx
movq 0x110(%r12), %rdx
shlq $0x5, %rcx
movl (%rdx,%rcx), %ecx
movq 0x10(%rsp), %rdx
addl %ecx, 0x4(%rdx)
addq $0x4, %rax
cmpq %r13, %rax
jne 0x2d9127
movq 0x10(%rsp), %r14
movl 0x4(%r14), %r15d
leaq (,%r15,4), %rax
leaq (%rax,%rax,2), %rbx
movq %rbx, %rdi
callq 0x1a57a0
testl %r15d, %r15d
movq %rax, 0x28(%rsp)
je 0x2d91a5
addq $-0xc, %rbx
movq %rbx, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0xc(,%rax,4), %rdx
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1a54e0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%r14)
movl 0x8(%r14), %r15d
movq %r15, %rbx
shlq $0x4, %rbx
leaq 0x8(%rbx), %rdi
callq 0x1a57a0
movq %r15, (%rax)
addq $0x8, %rax
testq %r15, %r15
je 0x2d91e6
addq %rax, %rbx
movq %rax, %rcx
movl $0x0, (%rcx)
movq $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rbx, %rcx
jne 0x2d91cf
movq %r13, 0x150(%rsp)
movq %rax, 0x98(%rsp)
movq %rax, 0xd0(%r14)
movq 0x68(%rsp), %rax
movl %eax, 0xe8(%r14)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x320(%rsp)
movdqa %xmm0, 0x330(%rsp)
movdqa %xmm0, 0x300(%rsp)
movdqa %xmm0, 0x310(%rsp)
imulq $0x148, %rax, %r15 # imm = 0x148
movq 0xa0(%rsp), %rsi
addq %r15, %rsi
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq 0x90(%rsp), %r13
movq %r13, %rdx
movq 0x70(%rsp), %r14
movq %r14, %rcx
leaq 0x320(%rsp), %r8
callq 0x2e2ecc
movq 0xa0(%rsp), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r13, %rdx
movq %r14, %rcx
leaq 0x300(%rsp), %r8
callq 0x2e33d6
xorl %r13d, %r13d
cmpl $-0x1, 0x320(%rsp,%r13,4)
je 0x2d932a
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x4(%rax), %r14d
leaq (,%r14,4), %rax
leaq (%rax,%rax,2), %rbx
movq %rbx, %rdi
callq 0x1a57a0
movq %rax, %rsi
testl %r14d, %r14d
je 0x2d92fc
addq $-0xc, %rbx
movq %rbx, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0xc(,%rax,4), %rdx
movq %rsi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1a54e0
movq %rbx, %rsi
movq 0x48(%rsp), %rax
movq %rsi, 0x70(%rax,%r13,8)
movq %rsi, 0x1a0(%rsp,%r13,8)
movq 0x10(%rsp), %rax
movl $0x2, 0xb0(%rax)
incq %r13
cmpq $0x8, %r13
jne 0x2d928f
cmpq $0x0, 0xb0(%r12)
je 0x2d9398
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x4(%rax), %r13d
leaq (,%r13,4), %rax
leaq (%rax,%rax,2), %rbx
movq %rbx, %rdi
callq 0x1a57a0
movq %rax, %r14
testl %r13d, %r13d
je 0x2d938d
addq $-0xc, %rbx
movq %rbx, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0xc(,%rax,4), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1a54e0
movq 0x48(%rsp), %rax
movq %r14, 0x18(%rax)
jmp 0x2d939b
xorl %r14d, %r14d
xorl %ebx, %ebx
cmpl $-0x1, 0x300(%rsp,%rbx,4)
je 0x2d9404
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x4(%rax), %r13d
movq %r13, 0x58(%rsp)
shlq $0x4, %r13
movq %r13, %rdi
callq 0x1a57a0
movq %rax, %rcx
cmpl $0x0, 0x58(%rsp)
je 0x2d93e9
movq %rcx, 0x58(%rsp)
movq 0x58(%rsp), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x1a54e0
movq 0x58(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x30(%rax,%rbx,8)
movq %rcx, 0xf0(%rsp,%rbx,8)
incq %rbx
cmpq $0x8, %rbx
jne 0x2d939d
movq 0x28(%r12), %rax
cmpq 0x30(%r12), %rax
je 0x2d9415
movq %rax, 0x30(%r12)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %esi
movl $0x0, 0x7c(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x7c(%rsp), %rdx
callq 0x24e364
movq 0x150(%rsp), %r13
movq 0x90(%rsp), %rax
movq (%rax), %rax
cmpq %r13, %rax
je 0x2d95fc
movq 0x60(%rsp), %rcx
movq (%rcx), %rcx
xorl %edx, %edx
movl (%rax), %edi
movq 0x110(%r12), %r8
shlq $0x5, %rdi
leaq (%r8,%rdi), %rsi
movl 0x14(%r8,%rdi), %r9d
movl %r9d, (%rcx)
cmpl $0x0, (%r8,%rdi)
je 0x2d95c2
xorl %edi, %edi
movq 0x28(%rsp), %r10
movq 0x8(%rsi), %r8
movl (%r8,%rdi,4), %r8d
movq 0x70(%rsp), %r9
movq (%r9), %r11
leaq (%r8,%r8,2), %r9
movl 0x8(%r11,%r9,4), %ebx
movl %ebx, 0x8(%r10)
movq (%r11,%r9,4), %r11
movq %r11, (%r10)
addq $0xc, %r10
movq %r10, 0x28(%rsp)
xorl %r10d, %r10d
movl 0x320(%rsp,%r10,4), %r11d
cmpq %rbp, %r11
je 0x2d9507
movq 0x88(%r12), %rbx
imulq $0x70, %r11, %r11
movq 0x30(%rbx,%r11), %r11
movss (%r11,%r8,8), %xmm0
movq 0x1a0(%rsp,%r10,8), %rbx
movss %xmm0, (%rbx)
movd 0x4(%r11,%r8,8), %xmm0
movd %xmm0, 0x4(%rbx)
addq $0xc, %rbx
movq %rbx, 0x1a0(%rsp,%r10,8)
incq %r10
cmpq $0x8, %r10
jne 0x2d94b6
testq %r14, %r14
je 0x2d953e
movq 0xd0(%r12), %r10
movl 0x8(%r10,%r9,4), %r11d
movl %r11d, 0x8(%r14)
movq (%r10,%r9,4), %r9
movq %r9, (%r14)
movd 0x8(%r14), %xmm0
pxor 0x281d6e(%rip), %xmm0 # 0x55b2a0
movd %xmm0, 0x8(%r14)
addq $0xc, %r14
jmp 0x2d9541
xorl %r14d, %r14d
xorl %r9d, %r9d
movl 0x300(%rsp,%r9,4), %r10d
cmpq %rbp, %r10
je 0x2d95a9
movq 0x70(%r12), %r11
imulq $0x70, %r10, %r10
movq 0x30(%r11,%r10), %r11
movq %r8, %rbx
shlq $0x4, %rbx
movq 0xf0(%rsp,%r9,8), %r10
movdqu (%r11,%rbx), %xmm0
movdqu %xmm0, (%r10)
movq 0xa0(%rsp), %r11
cmpl $0x52474220, 0x70(%r11,%r15) # imm = 0x52474220
jne 0x2d9594
movl $0x3f800000, 0xc(%r10) # imm = 0x3F800000
addq $0x10, %r10
movq %r10, 0xf0(%rsp,%r9,8)
incq %r9
cmpq $0x8, %r9
jne 0x2d9544
movq 0x8(%rsi), %r8
movl %edx, (%r8,%rdi,4)
incq %rdi
incl %edx
movl (%rsi), %r8d
cmpq %r8, %rdi
jb 0x2d9481
movq 0x8(%rsi), %rdi
movq 0x98(%rsp), %r8
movq %rdi, 0x8(%r8)
movl (%rsi), %edi
movl %edi, (%r8)
movq $0x0, 0x8(%rsi)
addq $0x10, %r8
movq %r8, 0x98(%rsp)
addq $0x4, %rax
addq $0x4, %rcx
cmpq %r13, %rax
jne 0x2d945a
movq 0x10(%rsp), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x2d9623
callq 0x241234
movq 0x68(%rsp), %rbx
movq %rax, %rdi
leaq 0x2c5d38(%rip), %rsi # 0x59f354
callq 0x241112
jmp 0x2d9642
addq 0xa0(%rsp), %r15
movq 0x18(%rsp), %rdi
movq 0x60(%rsp), %rdx
movq %r15, %rcx
callq 0x2daa50
movq 0x68(%rsp), %rbx
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movq (%rax), %rcx
incl %ebx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x7063e7063e7063e7, %rsi # imm = 0x8F9C18F9C18F9C19
imulq %rsi, %rdx
cmpq %rbx, %rdx
ja 0x2d9026
leaq 0xc0(%rsp), %rdi
callq 0x25082e
movq 0x38(%rsp), %r13
subq 0x30(%rsp), %r13
sarq $0x3, %r13
movq 0x80(%rsp), %r15
movq 0x88(%rsp), %rcx
jmp 0x2d96a5
movq %rcx, %r13
subq %rcx, %r13
leaq 0x138(%r12), %rbx
movq %rbx, %rdi
leaq 0x2c5b82(%rip), %rsi # 0x59f23c
callq 0x1a60c0
orl %r13d, %eax
je 0x2d977a
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x2402f8
movq 0x140(%r12), %r15
cmpq $0x3ff, %r15 # imm = 0x3FF
ja 0x2d9709
movl %r15d, (%r14)
movq %r14, %rdi
addq $0x4, %rdi
movq (%rbx), %rsi
movq %r15, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r14,%r15)
movq 0x70(%rsp), %rax
movq %rax, 0x448(%r14)
movl %r13d, 0x460(%r14)
testl %r13d, %r13d
movq 0x80(%rsp), %r15
je 0x2d9762
movl %r13d, %edi
shlq $0x2, %rdi
callq 0x1a57a0
movq %rax, 0x468(%r14)
xorl %eax, %eax
movq 0x88(%rsp), %rsi
leal (%rsi,%rax), %ecx
movq 0x468(%r14), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
movl 0x460(%r14), %ecx
cmpq %rcx, %rax
jb 0x2d9746
leaq 0x132(%r12), %rsi
leaq 0x158(%rsp), %rdi
callq 0x2de3fc
movq %r14, (%rax)
movq (%r12), %r12
cmpq %r15, %r12
jne 0x2d8db4
cmpq $0x0, 0x180(%rsp)
je 0x2d9931
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r14
cmpq %r14, %rbx
je 0x2d9931
movq 0x18(%rsp), %r12
movq 0xa0(%r12), %rax
movq 0x8(%rax), %r15
subq (%rax), %r15
sarq $0x3, %r15
movabsq $-0x7063e7063e7063e7, %rax # imm = 0x8F9C18F9C18F9C19
imulq %rax, %r15
movq 0x148(%rsp), %rbp
movl %r15d, 0x20(%rbp)
movl %r15d, %edi
shlq $0x3, %rdi
movq 0x8(%rsp), %r13
callq 0x1a57a0
movq %rax, 0x28(%rbp)
testl %r15d, %r15d
je 0x2d984c
xorl %ebx, %ebx
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x2466d0
movq 0x28(%rbp), %rax
movq %r14, (%rax,%r15,8)
movq 0xa0(%r12), %rax
movq (%rax), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0x2e2806
incq %r15
movl 0x20(%rbp), %eax
addq $0x148, %rbx # imm = 0x148
cmpq %rax, %r15
jb 0x2d97fa
movq 0x30(%rsp), %rbx
movq 0x38(%rsp), %r14
movabsq $0x7fffffff8, %rax # imm = 0x7FFFFFFF8
subq %rbx, %r14
movq %r14, %rcx
shrq $0x3, %rcx
movl %ecx, 0x10(%rbp)
andq %rax, %r14
movq %r14, %rdi
callq 0x1a57a0
movq %rax, 0x18(%rbp)
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1a5110
leaq 0x158(%rsp), %rsi
movq %r12, %rdi
callq 0x2db104
leaq 0x158(%rsp), %rdi
callq 0x2df2cc
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2d98b4
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x130(%rsp), %rdi
testq %rdi, %rdi
je 0x2d98d1
movq 0x140(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
leaq 0x340(%rsp), %rdi
callq 0x23c89e
leaq 0xa0(%rsp), %rdi
callq 0x2de464
leaq 0x188(%rsp), %rdi
callq 0x2df31c
movq 0xd8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d9915
movq 0xe8(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
addq $0x358, %rsp # imm = 0x358
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x1a0(%rsp), %rdi
leaq 0x1b0(%rsp), %rax
movq %rax, (%rdi)
leaq 0x2c5a34(%rip), %rsi # 0x59f38c
leaq 0x2c5a42(%rip), %rdx # 0x59f3a1
callq 0x209290
movb $0x1, %bpl
leaq 0x1a0(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x403dba(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x403d86(%rip), %rsi # 0x6dd710
movq 0x4d25cf(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2d9d2d
movq %rbp, %r15
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x2c5839(%rip), %rsi # 0x59f1ee
leaq 0xf0(%rsp), %rdi
movq %rbx, %rdx
callq 0x23ca59
leaq 0x2c1552(%rip), %rsi # 0x59af1e
leaq 0xf0(%rsp), %rdi
callq 0x1a5ba0
movq %r15, 0x1a0(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2d9c6d
movdqu (%rcx), %xmm0
movdqu %xmm0, (%r15)
jmp 0x2d9c80
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x1a0(%rsp), %rdi
movq %rbp, %r15
movq %rbp, (%rdi)
leaq 0x2c57e3(%rip), %rsi # 0x59f207
leaq 0x2c5810(%rip), %rdx # 0x59f23b
callq 0x209290
movb $0x1, %bpl
leaq 0x1a0(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x403cee(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x403cba(%rip), %rsi # 0x6dd710
movq 0x4d2503(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2d9d2d
movq 0x8(%rsp), %r13
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x1a0(%rsp), %rdi
leaq 0x1b0(%rsp), %rax
movq %rax, %r15
movq %rax, (%rdi)
leaq 0x2c6173(%rip), %rsi # 0x59fc0c
leaq 0x2c619e(%rip), %rdx # 0x59fc3e
callq 0x209290
movb $0x1, %bpl
leaq 0x1a0(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x403c79(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x403c45(%rip), %rsi # 0x6dd710
movq 0x4d248e(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2d9d2d
movq 0x8(%rsp), %r13
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x1a0(%rsp), %rdi
leaq 0x1b0(%rsp), %rax
movq %rax, %r15
movq %rax, (%rdi)
leaq 0x2c57c1(%rip), %rsi # 0x59f2cf
leaq 0x2c57e1(%rip), %rdx # 0x59f2f6
callq 0x209290
movb $0x1, %bpl
leaq 0x1a0(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x403c04(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x403bd0(%rip), %rsi # 0x6dd710
movq 0x4d2419(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2d9d2d
leaq 0x1b0(%rsp), %r15
movq 0x8(%rsp), %r13
addq $0xf8, %rbp
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x2c577b(%rip), %rsi # 0x59f2f7
leaq 0x1a0(%rsp), %rdi
movq %rbp, %rdx
callq 0x23ca59
movb $0x1, %bpl
leaq 0x1a0(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x403b92(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x403b5e(%rip), %rsi # 0x6dd710
movq 0x4d23a7(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2d9d2d
leaq 0x1b0(%rsp), %r12
movq 0x8(%rsp), %r13
movl %ecx, %eax
shrl $0x18, %eax
movb %al, 0x158(%rsp)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x159(%rsp)
movb %ch, 0x15a(%rsp)
movb %cl, 0x15b(%rsp)
movb $0x0, 0x15c(%rsp)
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x100(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c5695(%rip), %rsi # 0x59f2b6
leaq 0x2c56a6(%rip), %rdx # 0x59f2ce
leaq 0xf0(%rsp), %rdi
callq 0x209290
leaq 0xf0(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x1a5ba0
movq %r12, 0x1a0(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2d9cce
movdqu (%rcx), %xmm0
movdqu %xmm0, (%r12)
jmp 0x2d9ce1
movq %rdx, 0x1a0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1b0(%rsp)
movq 0x8(%rax), %rdx
leaq 0x1a0(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x1a53e0
leaq 0x403a87(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x403a53(%rip), %rsi # 0x6dd710
movq 0x4d229c(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2d9d2d
movq %rdx, 0x1a0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x1b0(%rsp)
movq 0x8(%rax), %rdx
leaq 0x1a0(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x1a53e0
leaq 0x403a26(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x4039f2(%rip), %rsi # 0x6dd710
movq 0x4d223b(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d9d4d
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0xf0(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9e3f
movq 0x100(%rsp), %rsi
jmp 0x2d9e37
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9e4c
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2d9e4c
jmp 0x2d9e49
jmp 0x2d9e1f
jmp 0x2d9e49
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9dc3
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d9de4
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2d9ed0
jmp 0x2da092
movq %rax, %rbx
leaq 0x100(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d9ed0
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2d9ed0
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9e3f
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2d9e4c
jmp 0x2da027
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x2da027
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9e79
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2d9e86
jmp 0x2da06b
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x2da06b
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d9eb3
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2d9ec0
jmp 0x2da088
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x2da088
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x2da092
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
leaq 0x1b0(%rsp), %rax
cmpq %rax, %rdi
je 0x2d9f05
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
movq 0x8(%rsp), %r13
jne 0x2d9f1c
jmp 0x2da003
movq %rax, %rbx
movq 0x8(%rsp), %r13
movq %r14, %rdi
callq 0x1a6080
jmp 0x2da003
jmp 0x2d9fa5
movq %rax, %rbx
leaq 0x1a0(%rsp), %rdi
callq 0x2de0d8
jmp 0x2d9f89
movq %rax, %rbx
jmp 0x2da06b
jmp 0x2d9f47
movq %rax, %rbx
jmp 0x2da088
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2da092
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2da092
movq %rax, %rbx
jmp 0x2da092
jmp 0x2d9fee
jmp 0x2d9fd9
jmp 0x2d9fa5
movq %rax, %rbx
movq 0x8(%rsp), %r13
jmp 0x2da027
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %r14, %rdi
callq 0x1a5190
jmp 0x2d9fa8
movq %rax, %rbx
movq 0x8(%rsp), %r13
jmp 0x2da003
movq %rax, %rbx
leaq 0x1a0(%rsp), %rdi
callq 0x2de368
jmp 0x2d9ff1
jmp 0x2d9fee
jmp 0x2d9fee
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x1a5190
jmp 0x2da003
jmp 0x2d9fee
movq %rax, %rbx
jmp 0x2da003
jmp 0x2d9fee
jmp 0x2d9fee
jmp 0x2d9fee
jmp 0x2d9fee
jmp 0x2d9fee
jmp 0x2d9fee
jmp 0x2d9fee
jmp 0x2d9fee
movq %rax, %rbx
movq 0x8(%rsp), %r13
leaq 0xc0(%rsp), %rdi
callq 0x25082e
leaq 0x158(%rsp), %rdi
callq 0x2df2cc
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2da027
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x130(%rsp), %rdi
testq %rdi, %rdi
je 0x2da044
movq 0x140(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
leaq 0x340(%rsp), %rdi
callq 0x23c89e
leaq 0xa0(%rsp), %rdi
callq 0x2de464
leaq 0x188(%rsp), %rdi
callq 0x2df31c
movq 0xd8(%rsp), %rdi
testq %rdi, %rdi
je 0x2da088
movq 0xe8(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOLoader.cpp |
Assimp::LWOImporter::LoadLWO2File() | void LWOImporter::LoadLWO2File()
{
bool skip = false;
LE_NCONST uint8_t* const end = mFileBuffer + fileSize;
unsigned int iUnnamed = 0;
while (true)
{
if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)break;
const IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
if (mFileBuffer + head.length > end)
{
throw DeadlyImportError("LWO2: Chunk length points behind the file");
break;
}
uint8_t* const next = mFileBuffer+head.length;
if(!head.length) {
mFileBuffer = next;
continue;
}
switch (head.type)
{
// new layer
case AI_LWO_LAYR:
{
// add a new layer to the list ....
mLayers->push_back ( LWO::Layer() );
LWO::Layer& layer = mLayers->back();
mCurLayer = &layer;
AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,LAYR,16);
// layer index.
layer.mIndex = GetU2();
// Continue loading this layer or ignore it? Check the layer index property
if (UINT_MAX != configLayerIndex && (configLayerIndex-1) != layer.mIndex) {
skip = true;
}
else skip = false;
// pivot point
mFileBuffer += 2; /* unknown */
mCurLayer->mPivot.x = GetF4();
mCurLayer->mPivot.y = GetF4();
mCurLayer->mPivot.z = GetF4();
GetS0(layer.mName,head.length-16);
// if the name is empty, generate a default name
if (layer.mName.empty()) {
char buffer[128]; // should be sufficiently large
::ai_snprintf(buffer, 128, "Layer_%i", iUnnamed++);
layer.mName = buffer;
}
// load this layer or ignore it? Check the layer name property
if (configLayerName.length() && configLayerName != layer.mName) {
skip = true;
}
else hasNamedLayer = true;
// optional: parent of this layer
if (mFileBuffer + 2 <= next)
layer.mParent = GetU2();
else layer.mParent = -1;
// Set layer skip parameter
layer.skip = skip;
break;
}
// vertex list
case AI_LWO_PNTS:
{
if (skip)
break;
unsigned int old = (unsigned int)mCurLayer->mTempPoints.size();
LoadLWOPoints(head.length);
mCurLayer->mPointIDXOfs = old;
break;
}
// vertex tags
case AI_LWO_VMAD:
if (mCurLayer->mFaces.empty())
{
ASSIMP_LOG_WARN("LWO2: Unexpected VMAD chunk");
break;
}
// --- intentionally no break here
case AI_LWO_VMAP:
{
if (skip)
break;
if (mCurLayer->mTempPoints.empty())
ASSIMP_LOG_WARN("LWO2: Unexpected VMAP chunk");
else LoadLWO2VertexMap(head.length,head.type == AI_LWO_VMAD);
break;
}
// face list
case AI_LWO_POLS:
{
if (skip)
break;
unsigned int old = (unsigned int)mCurLayer->mFaces.size();
LoadLWO2Polygons(head.length);
mCurLayer->mFaceIDXOfs = old;
break;
}
// polygon tags
case AI_LWO_PTAG:
{
if (skip)
break;
if (mCurLayer->mFaces.empty()) {
ASSIMP_LOG_WARN("LWO2: Unexpected PTAG");
} else {
LoadLWO2PolygonTags(head.length);
}
break;
}
// list of tags
case AI_LWO_TAGS:
{
if (!mTags->empty()) {
ASSIMP_LOG_WARN("LWO2: SRFS chunk encountered twice");
} else {
LoadLWOTags(head.length);
}
break;
}
// surface chunk
case AI_LWO_SURF:
{
LoadLWO2Surface(head.length);
break;
}
// clip chunk
case AI_LWO_CLIP:
{
LoadLWO2Clip(head.length);
break;
}
// envelope chunk
case AI_LWO_ENVL:
{
LoadLWO2Envelope(head.length);
break;
}
}
mFileBuffer = next;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl 0xe0(%rdi), %r14d
cmpq $0x8, %r14
jae 0x2da0ca
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
movq 0xd8(%rdi), %r12
addq %r12, %r14
leaq 0x8(%r12), %rax
xorl %r13d, %r13d
movq $0x0, 0x18(%rsp)
leaq 0x4(%r12), %rcx
movl (%r12), %ebp
movq %rcx, 0xd8(%rbx)
movl 0x4(%r12), %ecx
movq %rax, 0xd8(%rbx)
shlq $0x20, %rbp
orq %rcx, %rbp
bswapq %rbp
movq %rbp, %r15
shrq $0x20, %r15
movq %rax, %r12
addq %r15, %r12
cmpq %r14, %r12
ja 0x2da6e9
testq %r15, %r15
jne 0x2da13f
movq %r12, 0xd8(%rbx)
leaq 0x8(%r12), %rax
cmpq %r14, %rax
jbe 0x2da0e8
jmp 0x2da0b8
cmpl $0x50544146, %ebp # imm = 0x50544146
jg 0x2da1af
cmpl $0x4c415951, %ebp # imm = 0x4C415951
jle 0x2da1e0
cmpl $0x4c415952, %ebp # imm = 0x4C415952
je 0x2da26d
cmpl $0x504e5453, %ebp # imm = 0x504E5453
je 0x2da494
cmpl $0x504f4c53, %ebp # imm = 0x504F4C53
jne 0x2da129
testb $0x1, %r13b
jne 0x2da129
movq 0x88(%rbx), %rax
movq 0x108(%rax), %rbp
subq 0x100(%rax), %rbp
shrq $0x5, %rbp
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2dbaaa
movq 0x88(%rbx), %rax
movl %ebp, 0x118(%rax)
jmp 0x2da129
cmpl $0x54414752, %ebp # imm = 0x54414752
jle 0x2da204
cmpl $0x54414753, %ebp # imm = 0x54414753
je 0x2da46c
cmpl $0x564d4144, %ebp # imm = 0x564D4144
je 0x2da4d3
cmpl $0x564d4150, %ebp # imm = 0x564D4150
je 0x2da4ea
jmp 0x2da129
cmpl $0x434c4950, %ebp # imm = 0x434C4950
je 0x2da228
cmpl $0x454e564c, %ebp # imm = 0x454E564C
jne 0x2da129
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2dd8f4
jmp 0x2da129
cmpl $0x50544147, %ebp # imm = 0x50544147
je 0x2da238
cmpl $0x53555246, %ebp # imm = 0x53555246
jne 0x2da129
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2e4382
jmp 0x2da129
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2dd13a
jmp 0x2da129
testb $0x1, %r13b
jne 0x2da129
movq 0x88(%rbx), %rax
movq 0x100(%rax), %rcx
cmpq 0x108(%rax), %rcx
je 0x2da6d0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2dbe64
jmp 0x2da129
movq 0x80(%rbx), %r13
movl $0x90, %edx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x1a54e0
leaq 0xd8(%rsp), %rax
movq %rax, 0xc8(%rsp)
xorl %edx, %edx
movq %rdx, 0xd0(%rsp)
movb %dl, 0xd8(%rsp)
movl $0x3, 0xe8(%rsp)
movq %rdx, 0x118(%rsp)
movl %edx, 0x120(%rsp)
movq %rdx, 0x128(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movl %edx, 0x38(%rax)
leaq 0x40521b(%rip), %rcx # 0x6df4f8
movq %rcx, 0xc0(%rsp)
movups %xmm0, 0x68(%rax)
movups %xmm0, 0x58(%rax)
movw $0x0, 0x78(%rax)
movw $0xffff, 0x152(%rsp) # imm = 0xFFFF
leaq 0x168(%rsp), %rcx
movq %rcx, 0x158(%rsp)
movq %rdx, 0x160(%rsp)
movb %dl, 0x168(%rsp)
movq %rdx, 0xa0(%rax)
movq %rdx, 0xa5(%rax)
movq %r13, %rdi
leaq 0x30(%rsp), %rsi
callq 0x2df38c
movq %rax, %rdi
movq %r13, %rsi
callq 0x1a5360
incq 0x10(%r13)
leaq 0x30(%rsp), %rdi
callq 0x2de0d8
movq 0x80(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rax
movq %rax, 0x88(%rbx)
shrq $0x24, %rbp
je 0x2da74a
movq 0xd8(%rbx), %rcx
movzwl (%rcx), %eax
addq $0x2, %rcx
rolw $0x8, %ax
movq %rcx, 0xd8(%rbx)
movw %ax, 0x132(%rdi)
movl 0xf4(%rbx), %ecx
cmpl $-0x1, %ecx
je 0x2da3a6
decl %ecx
movzwl %ax, %eax
movb $0x1, %dl
cmpl %eax, %ecx
jne 0x2da3a8
xorl %edx, %edx
movl %edx, 0x14(%rsp)
movq 0x88(%rbx), %rax
movq 0xd8(%rbx), %rcx
leaq 0x2(%rcx), %rdx
movq %rdx, 0xd8(%rbx)
movl 0x2(%rcx), %edx
addq $0x6, %rcx
movq %rcx, 0xd8(%rbx)
bswapl %edx
movl %edx, 0x148(%rax)
movq 0x88(%rbx), %rax
movq 0xd8(%rbx), %rcx
movl (%rcx), %edx
addq $0x4, %rcx
movq %rcx, 0xd8(%rbx)
bswapl %edx
movl %edx, 0x14c(%rax)
movq 0x88(%rbx), %rax
movq 0xd8(%rbx), %rcx
movl (%rcx), %edx
addq $0x4, %rcx
movq %rcx, 0xd8(%rbx)
bswapl %edx
movl %edx, 0x150(%rax)
movq 0xd8(%rbx), %rsi
cmpb $0x0, (%rsi)
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
je 0x2da56d
addl $-0x10, %r15d
leaq 0x1(%rsi), %rax
movl $0x1, %ecx
cmpl %r15d, %ecx
ja 0x2da547
movq %rax, 0xd8(%rbx)
incl %ecx
leaq 0x1(%rax), %r13
cmpb $0x0, (%rax)
movq %r13, %rax
jne 0x2da446
decq %r13
jmp 0x2da56d
movq 0x90(%rbx), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x2da523
callq 0x241234
movq %rax, %rdi
leaq 0x2c5708(%rip), %rsi # 0x59fb97
jmp 0x2da6df
testb $0x1, %r13b
jne 0x2da129
movq 0x88(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x2, %rcx
imull $0xaaaaaaab, %ecx, %ebp # imm = 0xAAAAAAAB
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2db8de
movq 0x88(%rbx), %rax
movl %ebp, 0x11c(%rax)
jmp 0x2da129
movq 0x88(%rbx), %rax
movq 0x100(%rax), %rcx
cmpq 0x108(%rax), %rcx
je 0x2da533
testb $0x1, %r13b
jne 0x2da129
movq 0x88(%rbx), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x2da6bf
xorl %edx, %edx
cmpl $0x564d4144, %ebp # imm = 0x564D4144
sete %dl
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2dc038
jmp 0x2da129
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2db812
jmp 0x2da129
callq 0x241234
movq %rax, %rdi
leaq 0x2c5607(%rip), %rsi # 0x59fb49
jmp 0x2da6df
movq %rsi, %r15
callq 0x241234
movq %rax, %rdi
leaq 0x2c5791(%rip), %rsi # 0x59fcea
callq 0x241182
movq %r15, %rsi
movq 0x8(%rsp), %rdi
movq 0xd8(%rbx), %r13
leaq 0x138(%rdi), %rbp
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rsi, 0x28(%rsp)
movq %r13, %rdx
callq 0x209290
movq %rbp, 0x20(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1a58d0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2da5bf
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
subq 0x28(%rsp), %r13
andl $0x1, %r13d
movq 0xd8(%rbx), %rax
negq %r13
addq %r13, %rax
addq $0x2, %rax
movq %rax, 0xd8(%rbx)
movq 0x8(%rsp), %rsi
cmpq $0x0, 0x140(%rsi)
jne 0x2da647
movq 0x18(%rsp), %rcx
leal 0x1(%rcx), %ebp
movl $0x80, %esi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
leaq 0x2c5535(%rip), %rdx # 0x59fb40
xorl %eax, %eax
callq 0x1a5890
movq 0x8(%rsp), %rax
movq 0x140(%rax), %r13
movq %r15, %rdi
callq 0x1a56a0
movq 0x20(%rsp), %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x1a5830
movq 0x8(%rsp), %rsi
movl %ebp, %eax
movq %rax, 0x18(%rsp)
movq 0x100(%rbx), %rdx
testq %rdx, %rdx
je 0x2da67c
movb $0x1, %r13b
cmpq 0x140(%rsi), %rdx
jne 0x2da68a
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0xf8(%rbx), %rdi
callq 0x1a5c20
movq 0x8(%rsp), %rsi
testl %eax, %eax
jne 0x2da68a
movb $0x1, 0x118(%rbx)
movl 0x14(%rsp), %eax
movl %eax, %r13d
movq 0xd8(%rbx), %rcx
leaq 0x2(%rcx), %rdx
movw $0xffff, %ax # imm = 0xFFFF
cmpq %r12, %rdx
ja 0x2da6ac
movzwl (%rcx), %eax
movq %rdx, 0xd8(%rbx)
rolw $0x8, %ax
movw %ax, 0x130(%rsi)
movb %r13b, 0x164(%rsi)
jmp 0x2da129
callq 0x241234
movq %rax, %rdi
leaq 0x2c5497(%rip), %rsi # 0x59fb65
jmp 0x2da6df
callq 0x241234
movq %rax, %rdi
leaq 0x2c54a2(%rip), %rsi # 0x59fb81
callq 0x241182
jmp 0x2da129
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
movq %rax, (%rdi)
leaq 0x2c53ef(%rip), %rsi # 0x59faf9
leaq 0x2c5411(%rip), %rdx # 0x59fb22
callq 0x209290
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x40300b(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x402fd7(%rip), %rsi # 0x6dd710
movq 0x4d1820(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2da7a9
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
movq %rax, (%rdi)
leaq 0x2c53b8(%rip), %rsi # 0x59fb23
leaq 0x2c53cd(%rip), %rdx # 0x59fb3f
callq 0x209290
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x402faa(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x402f76(%rip), %rsi # 0x6dd710
movq 0x4d17bf(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x2da7bc
jmp 0x2da7e2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2de0d8
jmp 0x2da7ed
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2da7db
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2da7e5
jmp 0x2da7ed
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOLoader.cpp |
Assimp::LWOImporter::LoadLWO2PolygonTags(unsigned int) | void LWOImporter::LoadLWO2PolygonTags(unsigned int length)
{
LE_NCONST uint8_t* const end = mFileBuffer+length;
AI_LWO_VALIDATE_CHUNK_LENGTH(length,PTAG,4);
uint32_t type = GetU4();
if (type != AI_LWO_SURF && type != AI_LWO_SMGP)
return;
while (mFileBuffer < end)
{
unsigned int i = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs;
unsigned int j = GetU2();
if (i >= mCurLayer->mFaces.size()) {
ASSIMP_LOG_WARN("LWO2: face index in PTAG is out of range");
continue;
}
switch (type) {
case AI_LWO_SURF:
mCurLayer->mFaces[i].surfaceIndex = j;
break;
case AI_LWO_SMGP: /* is that really used? */
mCurLayer->mFaces[i].smoothGroup = j;
break;
};
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, %esi
jbe 0x2dbfa4
movq %rdi, %rbx
movq 0xd8(%rdi), %r15
movl (%r15), %ebp
leaq 0x4(%r15), %rax
movq %rax, 0xd8(%rdi)
bswapl %ebp
cmpl $0x53555246, %ebp # imm = 0x53555246
je 0x2dbea5
cmpl $0x534d4750, %ebp # imm = 0x534D4750
jne 0x2dbf99
cmpl $0x4, %esi
je 0x2dbf99
movl %esi, %ecx
addq %rcx, %r15
leaq 0x2c3722(%rip), %r14 # 0x59f5dc
movzbl (%rax), %edx
leaq 0x1(%rax), %rcx
movq %rcx, 0xd8(%rbx)
cmpl $0xff, %edx
je 0x2dbeda
shll $0x8, %edx
movl $0x2, %esi
jmp 0x2dbf05
movzbl 0x1(%rax), %esi
leaq 0x2(%rax), %rcx
movq %rcx, 0xd8(%rbx)
shll $0x10, %esi
movzbl 0x2(%rax), %edx
leaq 0x3(%rax), %rcx
movq %rcx, 0xd8(%rbx)
shll $0x8, %edx
orl %esi, %edx
movl $0x4, %esi
movzbl (%rcx), %ecx
addl %edx, %ecx
leaq (%rax,%rsi), %rdx
movq %rdx, 0xd8(%rbx)
movq 0x88(%rbx), %rdi
addl 0x118(%rdi), %ecx
addq %rsi, %rax
addq $0x2, %rax
movzwl -0x2(%rax), %edx
movq %rax, 0xd8(%rbx)
movq 0x100(%rdi), %rax
movq 0x108(%rdi), %rsi
subq %rax, %rsi
sarq $0x5, %rsi
cmpq %rcx, %rsi
jbe 0x2dbf6f
rolw $0x8, %dx
movzwl %dx, %edx
cmpl $0x534d4750, %ebp # imm = 0x534D4750
je 0x2dbf81
cmpl $0x53555246, %ebp # imm = 0x53555246
jne 0x2dbf89
shlq $0x5, %rcx
movl %edx, 0x10(%rax,%rcx)
jmp 0x2dbf89
callq 0x241234
movq %rax, %rdi
movq %r14, %rsi
callq 0x241182
jmp 0x2dbf89
shlq $0x5, %rcx
movl %edx, 0x14(%rax,%rcx)
movq 0xd8(%rbx), %rax
cmpq %r15, %rax
jb 0x2dbeba
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 0x2c35fe(%rip), %rsi # 0x59f5bf
leaq 0x2c3613(%rip), %rdx # 0x59f5db
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x40174f(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x40171b(%rip), %rsi # 0x6dd710
movq 0x4cff64(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2dc01e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2dc028
jmp 0x2dc030
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOLoader.cpp |
Assimp::LWOImporter::LoadLWO2ImageMap(unsigned int, Assimp::LWO::Texture&) | void LWOImporter::LoadLWO2ImageMap(unsigned int size, LWO::Texture& tex )
{
LE_NCONST uint8_t* const end = mFileBuffer + size;
while (true)
{
if (mFileBuffer + 6 >= end)break;
LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer);
if (mFileBuffer + head.length > end)
throw DeadlyImportError("LWO2: Invalid SURF.BLOCK chunk length");
uint8_t* const next = mFileBuffer+head.length;
switch (head.type)
{
case AI_LWO_PROJ:
tex.mapMode = (Texture::MappingMode)GetU2();
break;
case AI_LWO_WRAP:
tex.wrapModeWidth = (Texture::Wrap)GetU2();
tex.wrapModeHeight = (Texture::Wrap)GetU2();
break;
case AI_LWO_AXIS:
tex.majorAxis = (Texture::Axes)GetU2();
break;
case AI_LWO_IMAG:
tex.mClipIdx = GetU2();
break;
case AI_LWO_VMAP:
GetS0(tex.mUVChannelIndex,head.length);
break;
case AI_LWO_WRPH:
tex.wrapAmountH = GetF4();
break;
case AI_LWO_WRPW:
tex.wrapAmountW = GetF4();
break;
}
mFileBuffer = next;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x7, %esi
jb 0x2e3a20
movq %rdi, %r14
movq 0xd8(%rdi), %r15
movl %esi, %r12d
addq %r15, %r12
leaq 0x6(%r15), %r13
leaq 0x30(%rdx), %rax
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %r15, %rax
movl (%r15), %esi
leaq 0x4(%r15), %rcx
movq %rcx, 0xd8(%r14)
movzwl 0x4(%r15), %ecx
rolw $0x8, %cx
movq %r13, 0xd8(%r14)
movzwl %cx, %ecx
leaq (%rcx,%r13), %r15
cmpq %r12, %r15
ja 0x2e3a2f
bswapl %esi
cmpl $0x564d414f, %esi # imm = 0x564D414F
jle 0x2e389a
cmpl $0x57525047, %esi # imm = 0x57525047
jg 0x2e38d9
cmpl $0x564d4150, %esi # imm = 0x564D4150
je 0x2e3925
cmpl $0x57524150, %esi # imm = 0x57524150
jne 0x2e3a0c
movzwl (%r13), %ecx
addq $0x8, %rax
movq %rax, 0xd8(%r14)
rolw $0x8, %cx
movzwl %cx, %eax
movl %eax, 0x70(%rdx)
movq 0xd8(%r14), %rax
movzwl (%rax), %ecx
addq $0x2, %rax
movq %rax, 0xd8(%r14)
rolw $0x8, %cx
movzwl %cx, %eax
movl %eax, 0x74(%rdx)
jmp 0x2e3a0c
cmpl $0x41584953, %esi # imm = 0x41584953
je 0x2e3906
cmpl $0x494d4147, %esi # imm = 0x494D4147
je 0x2e3969
cmpl $0x50524f4a, %esi # imm = 0x50524F4A
jne 0x2e3a0c
movzwl (%r13), %ecx
addq $0x8, %rax
movq %rax, 0xd8(%r14)
rolw $0x8, %cx
movzwl %cx, %eax
movl %eax, 0x60(%rdx)
jmp 0x2e3a0c
cmpl $0x57525048, %esi # imm = 0x57525048
je 0x2e3950
cmpl $0x57525057, %esi # imm = 0x57525057
jne 0x2e3a0c
movl (%r13), %ecx
addq $0xa, %rax
movq %rax, 0xd8(%r14)
bswapl %ecx
movl %ecx, 0x6c(%rdx)
jmp 0x2e3a0c
movzwl (%r13), %ecx
addq $0x8, %rax
movq %rax, 0xd8(%r14)
rolw $0x8, %cx
movzwl %cx, %eax
movl %eax, 0x64(%rdx)
jmp 0x2e3a0c
cmpb $0x0, (%r13)
movq %r13, %rbp
je 0x2e39a3
leaq 0x1(%r13), %rax
subl $0x1, %ecx
jb 0x2e3988
movq %rax, 0xd8(%r14)
leaq 0x1(%rax), %rbp
cmpb $0x0, (%rax)
movq %rbp, %rax
jne 0x2e3933
decq %rbp
jmp 0x2e39a3
movl (%r13), %ecx
addq $0xa, %rax
movq %rax, 0xd8(%r14)
bswapl %ecx
movl %ecx, 0x68(%rdx)
jmp 0x2e3a0c
movzwl (%r13), %ecx
addq $0x8, %rax
movq %rax, 0xd8(%r14)
rolw $0x8, %cx
movzwl %cx, %eax
movl %eax, 0x20(%rdx)
jmp 0x2e3a0c
callq 0x241234
movq %rax, %rdi
leaq 0x2bc353(%rip), %rsi # 0x59fcea
callq 0x241182
movq 0xd8(%r14), %rbp
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x209290
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x1a58d0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e39e9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
subq %r13, %rbp
andl $0x1, %ebp
movq 0xd8(%r14), %rax
negq %rbp
addq %rbp, %rax
addq $0x2, %rax
movq %rax, 0xd8(%r14)
movq 0x30(%rsp), %rdx
movq %r15, 0xd8(%r14)
leaq 0x6(%r15), %r13
cmpq %r12, %r13
jb 0x2e37fd
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x2bc80e(%rip), %rsi # 0x5a025e
leaq 0x2bc82c(%rip), %rdx # 0x5a0283
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f9cc5(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f9c91(%rip), %rsi # 0x6dd710
movq 0x4c84da(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e3aad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2e3ab7
jmp 0x2e3abf
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOMaterial.cpp |
Assimp::LWO::Surface::operator=(Assimp::LWO::Surface const&) | Surface()
: mColor (0.78431f,0.78431f,0.78431f)
, bDoubleSided (false)
, mDiffuseValue (1.f)
, mSpecularValue (0.f)
, mTransparency (0.f)
, mGlossiness (0.4f)
, mLuminosity (0.f)
, mColorHighlights (0.f)
, mMaximumSmoothAngle (0.f) // 0 == not specified, no smoothing
, mVCMap ("")
, mVCMapType (AI_LWO_RGBA)
, mIOR (1.f) // vakuum
, mBumpIntensity (1.f)
, mWireframe (false)
, mAdditiveTransparency (0.f)
{} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1a64a0
movss 0x20(%r14), %xmm0
movss %xmm0, 0x20(%rbx)
movss 0x24(%r14), %xmm0
movss %xmm0, 0x24(%rbx)
movss 0x28(%r14), %xmm0
movss %xmm0, 0x28(%rbx)
movups 0x2c(%r14), %xmm0
movups 0x3c(%r14), %xmm1
movups %xmm0, 0x2c(%rbx)
movups %xmm1, 0x3c(%rbx)
leaq 0x50(%rbx), %rdi
leaq 0x50(%r14), %rsi
callq 0x1a64a0
movl 0x70(%r14), %eax
movl %eax, 0x70(%rbx)
cmpq %r14, %rbx
je 0x2e552a
leaq 0x78(%r14), %rdx
leaq 0x78(%rbx), %rdi
movq 0x78(%r14), %rsi
callq 0x2e5544
movl $0x90, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x90(%r14), %rsi
callq 0x2e56ce
movl $0xa8, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xa8(%r14), %rsi
callq 0x2e56ce
movl $0xc0, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xc0(%r14), %rsi
callq 0x2e56ce
movl $0xd8, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xd8(%r14), %rsi
callq 0x2e56ce
movl $0xf0, %edi
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0xf0(%r14), %rsi
callq 0x2e56ce
movl $0x108, %edi # imm = 0x108
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x108(%r14), %rsi
callq 0x2e56ce
movl $0x120, %edi # imm = 0x120
leaq (%r14,%rdi), %rdx
addq %rbx, %rdi
movq 0x120(%r14), %rsi
callq 0x2e56ce
movups 0x138(%r14), %xmm0
movups %xmm0, 0x138(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOFileData.h |
Assimp::MD2Importer::SetupProperties(Assimp::Importer const*) | void MD2Importer::SetupProperties(const Importer* pImp)
{
// The
// AI_CONFIG_IMPORT_MD2_KEYFRAME option overrides the
// AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD2_KEYFRAME,-1);
if(static_cast<unsigned int>(-1) == configFrameID){
configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2b6d99(%rip), %rsi # 0x5a0d56
movq %r14, %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x23ba82
movl %eax, 0x78(%rbx)
cmpl $-0x1, %eax
jne 0x2e9fe6
leaq 0x2b6d91(%rip), %rsi # 0x5a0d6a
movq %r14, %rdi
xorl %edx, %edx
callq 0x23ba82
movl %eax, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /hbina[P]fatuous/thirdparty/assimp/code/MD2/MD2Loader.cpp |
Assimp::MD2Importer::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void MD2Importer::InternReadFile( const std::string& pFile,
aiScene* pScene, IOSystem* pIOHandler)
{
std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
// Check whether we can read from the file
if( file.get() == NULL)
throw DeadlyImportError( "Failed to open MD2 file " + pFile + "");
// check whether the md3 file is large enough to contain
// at least the file header
fileSize = (unsigned int)file->FileSize();
if( fileSize < sizeof(MD2::Header))
throw DeadlyImportError( "MD2 File is too small");
std::vector<uint8_t> mBuffer2(fileSize);
file->Read(&mBuffer2[0], 1, fileSize);
mBuffer = &mBuffer2[0];
m_pcHeader = (BE_NCONST MD2::Header*)mBuffer;
#ifdef AI_BUILD_BIG_ENDIAN
ByteSwap::Swap4(&m_pcHeader->frameSize);
ByteSwap::Swap4(&m_pcHeader->magic);
ByteSwap::Swap4(&m_pcHeader->numFrames);
ByteSwap::Swap4(&m_pcHeader->numGlCommands);
ByteSwap::Swap4(&m_pcHeader->numSkins);
ByteSwap::Swap4(&m_pcHeader->numTexCoords);
ByteSwap::Swap4(&m_pcHeader->numTriangles);
ByteSwap::Swap4(&m_pcHeader->numVertices);
ByteSwap::Swap4(&m_pcHeader->offsetEnd);
ByteSwap::Swap4(&m_pcHeader->offsetFrames);
ByteSwap::Swap4(&m_pcHeader->offsetGlCommands);
ByteSwap::Swap4(&m_pcHeader->offsetSkins);
ByteSwap::Swap4(&m_pcHeader->offsetTexCoords);
ByteSwap::Swap4(&m_pcHeader->offsetTriangles);
ByteSwap::Swap4(&m_pcHeader->skinHeight);
ByteSwap::Swap4(&m_pcHeader->skinWidth);
ByteSwap::Swap4(&m_pcHeader->version);
#endif
ValidateHeader();
// there won't be more than one mesh inside the file
pScene->mNumMaterials = 1;
pScene->mRootNode = new aiNode();
pScene->mRootNode->mNumMeshes = 1;
pScene->mRootNode->mMeshes = new unsigned int[1];
pScene->mRootNode->mMeshes[0] = 0;
pScene->mMaterials = new aiMaterial*[1];
pScene->mMaterials[0] = new aiMaterial();
pScene->mNumMeshes = 1;
pScene->mMeshes = new aiMesh*[1];
aiMesh* pcMesh = pScene->mMeshes[0] = new aiMesh();
pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
// navigate to the begin of the current frame data
BE_NCONST MD2::Frame* pcFrame = (BE_NCONST MD2::Frame*) ((uint8_t*)
m_pcHeader + m_pcHeader->offsetFrames + (m_pcHeader->frameSize * configFrameID));
// navigate to the begin of the triangle data
MD2::Triangle* pcTriangles = (MD2::Triangle*) ((uint8_t*)
m_pcHeader + m_pcHeader->offsetTriangles);
// navigate to the begin of the tex coords data
BE_NCONST MD2::TexCoord* pcTexCoords = (BE_NCONST MD2::TexCoord*) ((uint8_t*)
m_pcHeader + m_pcHeader->offsetTexCoords);
// navigate to the begin of the vertex data
BE_NCONST MD2::Vertex* pcVerts = (BE_NCONST MD2::Vertex*) (pcFrame->vertices);
#ifdef AI_BUILD_BIG_ENDIAN
for (uint32_t i = 0; i< m_pcHeader->numTriangles; ++i)
{
for (unsigned int p = 0; p < 3;++p)
{
ByteSwap::Swap2(& pcTriangles[i].textureIndices[p]);
ByteSwap::Swap2(& pcTriangles[i].vertexIndices[p]);
}
}
for (uint32_t i = 0; i < m_pcHeader->offsetTexCoords;++i)
{
ByteSwap::Swap2(& pcTexCoords[i].s);
ByteSwap::Swap2(& pcTexCoords[i].t);
}
ByteSwap::Swap4( & pcFrame->scale[0] );
ByteSwap::Swap4( & pcFrame->scale[1] );
ByteSwap::Swap4( & pcFrame->scale[2] );
ByteSwap::Swap4( & pcFrame->translate[0] );
ByteSwap::Swap4( & pcFrame->translate[1] );
ByteSwap::Swap4( & pcFrame->translate[2] );
#endif
pcMesh->mNumFaces = m_pcHeader->numTriangles;
pcMesh->mFaces = new aiFace[m_pcHeader->numTriangles];
// allocate output storage
pcMesh->mNumVertices = (unsigned int)pcMesh->mNumFaces*3;
pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
// Not sure whether there are MD2 files without texture coordinates
// NOTE: texture coordinates can be there without a texture,
// but a texture can't be there without a valid UV channel
aiMaterial* pcHelper = (aiMaterial*)pScene->mMaterials[0];
const int iMode = (int)aiShadingMode_Gouraud;
pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
if (m_pcHeader->numTexCoords && m_pcHeader->numSkins)
{
// navigate to the first texture associated with the mesh
const MD2::Skin* pcSkins = (const MD2::Skin*) ((unsigned char*)m_pcHeader +
m_pcHeader->offsetSkins);
aiColor3D clr;
clr.b = clr.g = clr.r = 1.0f;
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
clr.b = clr.g = clr.r = 0.05f;
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
if (pcSkins->name[0])
{
aiString szString;
const ai_uint32 iLen = (ai_uint32) ::strlen(pcSkins->name);
::memcpy(szString.data,pcSkins->name,iLen);
szString.data[iLen] = '\0';
szString.length = iLen;
pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0));
}
else{
ASSIMP_LOG_WARN("Texture file name has zero length. It will be skipped.");
}
}
else {
// apply a default material
aiColor3D clr;
clr.b = clr.g = clr.r = 0.6f;
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
clr.b = clr.g = clr.r = 0.05f;
pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
aiString szName;
szName.Set(AI_DEFAULT_MATERIAL_NAME);
pcHelper->AddProperty(&szName,AI_MATKEY_NAME);
aiString sz;
// TODO: Try to guess the name of the texture file from the model file name
sz.Set("$texture_dummy.bmp");
pcHelper->AddProperty(&sz,AI_MATKEY_TEXTURE_DIFFUSE(0));
}
// now read all triangles of the first frame, apply scaling and translation
unsigned int iCurrent = 0;
float fDivisorU = 1.0f,fDivisorV = 1.0f;
if (m_pcHeader->numTexCoords) {
// allocate storage for texture coordinates, too
pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
pcMesh->mNumUVComponents[0] = 2;
// check whether the skin width or height are zero (this would
// cause a division through zero)
if (!m_pcHeader->skinWidth) {
ASSIMP_LOG_ERROR("MD2: No valid skin width given");
}
else fDivisorU = (float)m_pcHeader->skinWidth;
if (!m_pcHeader->skinHeight){
ASSIMP_LOG_ERROR("MD2: No valid skin height given");
}
else fDivisorV = (float)m_pcHeader->skinHeight;
}
for (unsigned int i = 0; i < (unsigned int)m_pcHeader->numTriangles;++i) {
// Allocate the face
pScene->mMeshes[0]->mFaces[i].mIndices = new unsigned int[3];
pScene->mMeshes[0]->mFaces[i].mNumIndices = 3;
// copy texture coordinates
// check whether they are different from the previous value at this index.
// In this case, create a full separate set of vertices/normals/texcoords
for (unsigned int c = 0; c < 3;++c,++iCurrent) {
// validate vertex indices
unsigned int iIndex = (unsigned int)pcTriangles[i].vertexIndices[c];
if (iIndex >= m_pcHeader->numVertices) {
ASSIMP_LOG_ERROR("MD2: Vertex index is outside the allowed range");
iIndex = m_pcHeader->numVertices-1;
}
// read x,y, and z component of the vertex
aiVector3D& vec = pcMesh->mVertices[iCurrent];
vec.x = (float)pcVerts[iIndex].vertex[0] * pcFrame->scale[0];
vec.x += pcFrame->translate[0];
vec.y = (float)pcVerts[iIndex].vertex[1] * pcFrame->scale[1];
vec.y += pcFrame->translate[1];
vec.z = (float)pcVerts[iIndex].vertex[2] * pcFrame->scale[2];
vec.z += pcFrame->translate[2];
// read the normal vector from the precalculated normal table
aiVector3D& vNormal = pcMesh->mNormals[iCurrent];
LookupNormalIndex(pcVerts[iIndex].lightNormalIndex,vNormal);
// flip z and y to become right-handed
std::swap((float&)vNormal.z,(float&)vNormal.y);
std::swap((float&)vec.z,(float&)vec.y);
if (m_pcHeader->numTexCoords) {
// validate texture coordinates
iIndex = pcTriangles[i].textureIndices[c];
if (iIndex >= m_pcHeader->numTexCoords) {
ASSIMP_LOG_ERROR("MD2: UV index is outside the allowed range");
iIndex = m_pcHeader->numTexCoords-1;
}
aiVector3D& pcOut = pcMesh->mTextureCoords[0][iCurrent];
// the texture coordinates are absolute values but we
// need relative values between 0 and 1
pcOut.x = pcTexCoords[iIndex].s / fDivisorU;
pcOut.y = 1.f-pcTexCoords[iIndex].t / fDivisorV;
}
pScene->mMeshes[0]->mFaces[i].mIndices[c] = iCurrent;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8a8, %rsp # imm = 0x8A8
movq %rcx, %rbx
movq %rdx, 0x18(%rsp)
movq %rsi, %r12
movq %rdi, 0x40(%rsp)
leaq 0xa8(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2c011b(%rip), %rsi # 0x5aa761
leaq 0x2c0116(%rip), %rdx # 0x5aa763
leaq 0x98(%rsp), %rdi
callq 0x209290
movq (%r12), %rsi
movq 0x98(%rsp), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, 0x38(%rsp)
movq 0x98(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ea691
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x2eb015
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x40(%rsp), %rcx
movl %eax, 0x90(%rcx)
movl %eax, %ecx
andl $-0x4, %ecx
cmpl $0x43, %ecx
jbe 0x2eb06e
movl %eax, %esi
leaq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x2de078
movq 0x68(%rsp), %rsi
movq 0x40(%rsp), %r13
movl 0x90(%r13), %ecx
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%r13)
movq %rax, 0x80(%r13)
movq %r13, %rdi
callq 0x2e9fee
movq 0x18(%rsp), %rax
movl $0x1, 0x20(%rax)
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r12
movq %rax, %rdi
callq 0x2402f8
movq 0x18(%rsp), %rax
movq %r12, 0x8(%rax)
movl $0x1, 0x460(%r12)
movl $0x4, %edi
callq 0x1a57a0
movq %rax, 0x468(%r12)
movl $0x0, (%rax)
movl $0x8, %edi
callq 0x1a57a0
movq 0x18(%rsp), %rcx
movq %rax, 0x28(%rcx)
movl $0x10, %edi
callq 0x1a5230
movq %rax, %rbx
movq %rax, %rdi
callq 0x2466d0
movq 0x18(%rsp), %rcx
movq 0x28(%rcx), %rax
movq %rbx, (%rax)
movl $0x1, 0x10(%rcx)
movl $0x8, %edi
callq 0x1a57a0
movq %rax, %rbp
movq 0x18(%rsp), %rax
movq %rbp, 0x18(%rax)
movl $0x520, %edi # imm = 0x520
callq 0x1a5230
movq $0x0, 0x4(%rax)
leaq 0x10(%rax), %rdi
movq %rax, %r15
leaq 0xf1(%rax), %rbx
xorl %r14d, %r14d
movl $0xcc, %edx
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
callq 0x1a54e0
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%r15)
movb $0x0, 0xf0(%r15)
movl $0x3ff, %edx # imm = 0x3FF
movq %rbx, %rdi
movl $0x1b, %esi
callq 0x1a54e0
movl %r14d, 0x4f0(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x4f8(%r15)
movups %xmm0, 0x508(%r15)
movl %r14d, 0x518(%r15)
movq %r15, %rdi
addq $0x30, %rdi
movl $0xa0, %edx
xorl %esi, %esi
callq 0x1a54e0
movq %r15, (%rbp)
movl $0x4, (%r15)
movq 0x80(%r13), %r12
movl 0x38(%r12), %eax
movq %rax, 0x48(%rsp)
movl 0x78(%r13), %eax
imull 0x10(%r12), %eax
movq %rax, 0x60(%rsp)
movl 0x34(%r12), %eax
movq %rax, 0x50(%rsp)
movl 0x20(%r12), %r14d
movl 0x30(%r12), %eax
movq %rax, 0x58(%rsp)
movq %r15, 0x10(%rsp)
movl %r14d, 0x8(%r15)
movl 0x20(%r12), %r15d
movq %r15, %rbx
shlq $0x4, %rbx
leaq 0x8(%rbx), %rdi
callq 0x1a57a0
movq %r15, (%rax)
addq $0x8, %rax
testq %r15, %r15
je 0x2ea8c5
addq %rax, %rbx
movq %rax, %rcx
movl $0x0, (%rcx)
movq $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rbx, %rcx
jne 0x2ea8ae
movq 0x10(%rsp), %rcx
movq %rax, 0xd0(%rcx)
leal (%r14,%r14,2), %eax
movl %eax, 0x4(%rcx)
shlq $0x2, %rax
leaq (%rax,%rax,2), %rbp
movq %rbp, %rdi
callq 0x1a57a0
movq %rax, %rbx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
testl %r14d, %r14d
je 0x2ea91b
leaq -0xc(%rbp), %rax
mulq %r15
shrq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0xc(,%rax,4), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1a54e0
movq 0x28(%rsp), %rax
movq %rbx, (%rax)
movq %rbp, %rdi
callq 0x1a57a0
movq %rax, %rbx
testl %r14d, %r14d
je 0x2ea957
addq $-0xc, %rbp
movq %rbp, %rax
mulq %r15
shrq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0xc(,%rax,4), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1a54e0
movq 0x10(%rsp), %rax
movq %rbx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %r15
leaq 0x94(%rsp), %rsi
movl $0x2, (%rsi)
movl $0x4, (%rsp)
leaq 0x2a6521(%rip), %rcx # 0x590ea9
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movq 0x80(%r13), %rbp
cmpl $0x0, 0x1c(%rbp)
je 0x2eaaeb
cmpl $0x0, 0x14(%rbp)
je 0x2eaaeb
movl 0x2c(%rbp), %ebx
movsd 0x27090f(%rip), %xmm0 # 0x55b2d0
leaq 0x4a0(%rsp), %rsi
movsd %xmm0, (%rsi)
movl $0x3f800000, 0x8(%rsi) # imm = 0x3F800000
movl $0x1, (%rsp)
leaq 0x2a4f3a(%rip), %rcx # 0x58f91c
movq %r15, %rdi
movl $0xc, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movl $0x1, (%rsp)
leaq 0x2adc2b(%rip), %rcx # 0x59862e
leaq 0x4a0(%rsp), %rsi
movq %r15, %rdi
movl $0xc, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movsd 0x2aad1a(%rip), %xmm0 # 0x595740
leaq 0x4a0(%rsp), %rsi
movsd %xmm0, (%rsi)
movl $0x3d4ccccd, 0x8(%rsi) # imm = 0x3D4CCCCD
movl $0x1, (%rsp)
leaq 0x2aadec(%rip), %rcx # 0x595833
movq %r15, %rdi
movl $0xc, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
addq %rbx, %rbp
cmpb $0x0, (%rbp)
je 0x2eaffc
leaq 0x9c(%rsp), %rax
movl $0x0, -0x4(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x9d(%rsp), %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
movq %rbp, %rdi
callq 0x1a56a0
movq %rax, %r14
movl %r14d, %ebx
leaq 0x9c(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1a5110
xorl %eax, %eax
movb %al, 0x9c(%rsp,%rbx)
leaq 0x9d(%rsp), %rax
movl %r14d, -0x5(%rax)
leaq 0x2a6026(%rip), %rdx # 0x590af4
leaq 0x98(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x246b54
jmp 0x2eac3e
movsd 0x2a4d1d(%rip), %xmm0 # 0x58f810
leaq 0x88(%rsp), %rsi
movsd %xmm0, (%rsi)
movl $0x3f19999a, 0x8(%rsi) # imm = 0x3F19999A
movl $0x1, (%rsp)
leaq 0x2a4e08(%rip), %rcx # 0x58f91c
movq %r15, %rdi
movl $0xc, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movl $0x1, (%rsp)
leaq 0x2adaf9(%rip), %rcx # 0x59862e
leaq 0x88(%rsp), %rsi
movq %r15, %rdi
movl $0xc, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movsd 0x2aabe8(%rip), %xmm0 # 0x595740
leaq 0x88(%rsp), %rsi
movsd %xmm0, (%rsi)
movl $0x3d4ccccd, 0x8(%rsi) # imm = 0x3D4CCCCD
movl $0x1, (%rsp)
leaq 0x2aacba(%rip), %rcx # 0x595833
movq %r15, %rdi
movl $0xc, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
leaq 0xac(%rsp), %rbx
movl $0x3f0, %edx # imm = 0x3F0
movq %rbx, %rdi
movl $0x1b, %esi
callq 0x1a54e0
movl $0xf, -0x14(%rbx)
movabsq $0x4d746c7561666544, %rax # imm = 0x4D746C7561666544
movq %rax, -0x10(%rbx)
movabsq $0x6c6169726574614d, %rax # imm = 0x6C6169726574614D
movq %rax, -0x9(%rbx)
movb $0x0, -0x1(%rbx)
leaq 0x2a4d65(%rip), %rdx # 0x58f939
leaq 0x98(%rsp), %rsi
movq %r15, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x246b54
leaq 0x4b7(%rsp), %rbx
movl $0x3ed, %edx # imm = 0x3ED
movq %rbx, %rdi
movl $0x1b, %esi
callq 0x1a54e0
movl $0x12, -0x17(%rbx)
movups 0x2b64a0(%rip), %xmm0 # 0x5a10b1
movups %xmm0, -0x13(%rbx)
movw $0x706d, -0x3(%rbx) # imm = 0x706D
movb $0x0, -0x1(%rbx)
leaq 0x2a5ece(%rip), %rdx # 0x590af4
leaq 0x4a0(%rsp), %rsi
movq %r15, %rdi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x246b54
movq 0x10(%rsp), %rbx
movq 0x80(%r13), %r14
movss 0x27095e(%rip), %xmm0 # 0x55b5b0
cmpl $0x0, 0x1c(%r14)
movss %xmm0, 0x34(%rsp)
je 0x2eacdd
movl 0x4(%rbx), %r15d
leaq (,%r15,4), %rax
leaq (%rax,%rax,2), %rbp
movq %rbp, %rdi
callq 0x1a57a0
movq %rax, %rbx
testl %r15d, %r15d
je 0x2eacad
addq $-0xc, %rbp
movq %rbp, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x3, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0xc(,%rax,4), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1a54e0
movq 0x10(%rsp), %rax
movq %rbx, 0x70(%rax)
movq %rax, %rbx
movl $0x2, 0xb0(%rax)
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x2eace5
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x2ead13
movss %xmm0, 0x24(%rsp)
jmp 0x2ead4d
callq 0x241234
leaq 0x2b63d3(%rip), %rsi # 0x5a10c4
movq %rax, %rdi
callq 0x2411ba
movq 0x80(%r13), %r14
movss 0x2708a8(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0x24(%rsp)
movq 0x10(%rsp), %rbx
movl 0xc(%r14), %eax
testl %eax, %eax
je 0x2ead2d
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x2ead4d
callq 0x241234
leaq 0x2b63aa(%rip), %rsi # 0x5a10e3
movq %rax, %rdi
callq 0x2411ba
movq 0x80(%r13), %r14
movq 0x10(%rsp), %rbx
cmpl $0x0, 0x20(%r14)
je 0x2eafc8
movq 0x48(%rsp), %rax
addq %r12, %rax
addq %rax, 0x60(%rsp)
addq %r12, 0x58(%rsp)
movq 0x50(%rsp), %rax
addq %r12, %rax
addq $0x6, %rax
movq %rax, 0x28(%rsp)
xorl %r14d, %r14d
movl $0x0, 0x30(%rsp)
movl $0xc, %edi
callq 0x1a57a0
movq 0x18(%rsp), %rdx
movq 0x18(%rdx), %rcx
movq (%rcx), %rcx
movq 0xd0(%rcx), %rcx
movq %r14, 0x80(%rsp)
shlq $0x4, %r14
movq %rax, 0x8(%rcx,%r14)
movq 0x18(%rdx), %rax
movq (%rax), %rax
movq 0xd0(%rax), %rax
movq %r14, 0x48(%rsp)
movl $0x3, (%rax,%r14)
movl 0x30(%rsp), %eax
movq %rax, 0x50(%rsp)
xorl %r14d, %r14d
movq 0x28(%rsp), %rax
movzwl -0x6(%rax,%r14,2), %eax
movq 0x80(%r13), %rcx
cmpl %eax, 0x18(%rcx)
ja 0x2eae12
callq 0x241234
movq %rax, %rdi
leaq 0x2b6302(%rip), %rsi # 0x5a1103
callq 0x2411ba
movq 0x80(%r13), %rax
movl 0x18(%rax), %eax
decl %eax
movq 0x50(%rsp), %rcx
leaq (%rcx,%r14), %r12
movq 0x10(%rbx), %rbp
movl %r12d, %r15d
movl %eax, %eax
movq 0x60(%rsp), %rdx
movzbl 0x28(%rdx,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
leaq (,%r15,4), %rcx
leaq (%rcx,%rcx,2), %r13
mulss (%rdx), %xmm0
movss %xmm0, (%rbp,%r13)
addss 0xc(%rdx), %xmm0
movss %xmm0, (%rbp,%r13)
movzbl 0x29(%rdx,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
mulss 0x4(%rdx), %xmm0
movss %xmm0, 0x4(%rbp,%r13)
addss 0x10(%rdx), %xmm0
movss %xmm0, 0x4(%rbp,%r13)
movzbl 0x2a(%rdx,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
mulss 0x8(%rdx), %xmm0
movss %xmm0, 0x8(%rbp,%r13)
addss 0x14(%rdx), %xmm0
movss %xmm0, 0x8(%rbp,%r13)
movq 0x18(%rbx), %rbx
addq %r13, %rbx
movzbl 0x2b(%rdx,%rax,4), %edi
movq %rbx, %rsi
callq 0x2e9e5c
addq %r13, %rbp
movsd 0x4(%rbx), %xmm0
shufps $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movlps %xmm0, 0x4(%rbx)
movsd 0x4(%rbp), %xmm0
shufps $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movlps %xmm0, 0x4(%rbp)
movq 0x40(%rsp), %r13
movq 0x80(%r13), %rax
movl 0x1c(%rax), %ecx
testl %ecx, %ecx
movq 0x10(%rsp), %rbx
je 0x2eaf6e
movq 0x28(%rsp), %rax
movzwl (%rax,%r14,2), %eax
cmpl %eax, %ecx
ja 0x2eaf25
callq 0x241234
movq %rax, %rdi
leaq 0x2b6228(%rip), %rsi # 0x5a1132
callq 0x2411ba
movq 0x40(%rsp), %r13
movq 0x80(%r13), %rax
movl 0x1c(%rax), %eax
decl %eax
movq 0x10(%rsp), %rbx
movl %eax, %eax
movq 0x58(%rsp), %rsi
movzwl (%rsi,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movq 0x70(%rbx), %rcx
leaq (%r15,%r15,2), %rdx
divss 0x24(%rsp), %xmm0
movss %xmm0, (%rcx,%rdx,4)
movzwl 0x2(%rsi,%rax,4), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x34(%rsp), %xmm0
movss 0x27064c(%rip), %xmm1 # 0x55b5b0
subss %xmm0, %xmm1
movss %xmm1, 0x4(%rcx,%rdx,4)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0xd0(%rax), %rax
movq 0x48(%rsp), %rcx
movq 0x8(%rax,%rcx), %rax
movl %r12d, (%rax,%r14,4)
incq %r14
cmpq $0x3, %r14
jne 0x2eaddb
movq 0x80(%rsp), %rcx
incq %rcx
movq 0x80(%r13), %rax
movl 0x20(%rax), %eax
addq $0xc, 0x28(%rsp)
addl %r14d, 0x30(%rsp)
movq %rcx, %r14
cmpq %rax, %rcx
jb 0x2ead86
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x2eafdf
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8a8, %rsp # imm = 0x8A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x241234
leaq 0x2b6072(%rip), %rsi # 0x5a107a
movq %rax, %rdi
callq 0x241182
jmp 0x2eac3e
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x2b6022(%rip), %rsi # 0x5a104b
leaq 0x4a0(%rsp), %rdi
movq %r12, %rdx
callq 0x23ca59
leaq 0x2bdb01(%rip), %rsi # 0x5a8b41
leaq 0x4a0(%rsp), %rdi
callq 0x1a5ba0
movq %r13, 0x98(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2eb0cf
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x2eb0e2
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r15
leaq 0x98(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x2b5fd7(%rip), %rsi # 0x5a1064
leaq 0x2b5fe5(%rip), %rdx # 0x5a1079
callq 0x209290
movb $0x1, %bl
leaq 0x98(%rsp), %rsi
movq %r15, %rdi
callq 0x1a53e0
leaq 0x3f2686(%rip), %rax # 0x6dd738
movq %rax, (%r15)
xorl %ebx, %ebx
leaq 0x3f2652(%rip), %rsi # 0x6dd710
movq 0x4c0e9b(%rip), %rdx # 0x7abf60
movq %r15, %rdi
callq 0x1a5b00
jmp 0x2eb12e
movq %rdx, 0x98(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa8(%rsp)
movq 0x8(%rax), %rdx
leaq 0x98(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f2625(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f25f1(%rip), %rsi # 0x6dd710
movq 0x4c0e3a(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2eb250
movq %rax, %r14
movq 0x98(%rsp), %rdi
cmpq %r13, %rdi
je 0x2eb153
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x4b0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eb174
movq 0x4b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2eb1e0
jmp 0x2eb275
movq %rax, %r14
leaq 0x4b0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eb1e0
movq 0x4b0(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2eb1e0
movq %rax, %r14
movq 0x98(%rsp), %rdi
cmpq %r13, %rdi
je 0x2eb1c4
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bl, %bl
jne 0x2eb1d0
jmp 0x2eb26a
movq %rax, %r14
movq %r15, %rdi
callq 0x1a6080
jmp 0x2eb26a
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
jmp 0x2eb275
jmp 0x2eb250
jmp 0x2eb250
jmp 0x2eb250
jmp 0x2eb250
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
jmp 0x2eb20d
movq %rax, %r14
movl $0x478, %esi # imm = 0x478
movq %r12, %rdi
callq 0x1a5190
jmp 0x2eb253
jmp 0x2eb216
movq %rax, %r14
jmp 0x2eb26a
movq %rax, %r14
movq 0x98(%rsp), %rdi
cmpq %r13, %rdi
je 0x2eb275
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2eb275
movq %rax, %r14
jmp 0x2eb275
jmp 0x2eb250
jmp 0x2eb250
jmp 0x2eb250
jmp 0x2eb250
jmp 0x2eb250
jmp 0x2eb250
jmp 0x2eb250
movq %rax, %r14
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x2eb26a
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x1a5b90
nopl (%rax)
| /hbina[P]fatuous/thirdparty/assimp/code/MD2/MD2Loader.cpp |
Assimp::Q3Shader::LoadShader(Assimp::Q3Shader::ShaderData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*) | bool Q3Shader::LoadShader(ShaderData& fill, const std::string& pFile,IOSystem* io)
{
std::unique_ptr<IOStream> file( io->Open( pFile, "rt"));
if (!file.get())
return false; // if we can't access the file, don't worry and return
ASSIMP_LOG_INFO_F("Loading Quake3 shader file ", pFile);
// read file in memory
const size_t s = file->FileSize();
std::vector<char> _buff(s+1);
file->Read(&_buff[0],s,1);
_buff[s] = 0;
// remove comments from it (C++ style)
CommentRemover::RemoveLineComments("//",&_buff[0]);
const char* buff = &_buff[0];
Q3Shader::ShaderDataBlock* curData = NULL;
Q3Shader::ShaderMapBlock* curMap = NULL;
// read line per line
for (;SkipSpacesAndLineEnd(&buff);SkipLine(&buff)) {
if (*buff == '{') {
++buff;
// append to last section, if any
if (!curData) {
ASSIMP_LOG_ERROR("Q3Shader: Unexpected shader section token \'{\'");
return true; // still no failure, the file is there
}
// read this data section
for (;SkipSpacesAndLineEnd(&buff);SkipLine(&buff)) {
if (*buff == '{') {
++buff;
// add new map section
curData->maps.push_back(Q3Shader::ShaderMapBlock());
curMap = &curData->maps.back();
for (;SkipSpacesAndLineEnd(&buff);SkipLine(&buff)) {
// 'map' - Specifies texture file name
if (TokenMatchI(buff,"map",3) || TokenMatchI(buff,"clampmap",8)) {
curMap->name = GetNextToken(buff);
}
// 'blendfunc' - Alpha blending mode
else if (TokenMatchI(buff,"blendfunc",9)) {
const std::string blend_src = GetNextToken(buff);
if (blend_src == "add") {
curMap->blend_src = Q3Shader::BLEND_GL_ONE;
curMap->blend_dest = Q3Shader::BLEND_GL_ONE;
}
else if (blend_src == "filter") {
curMap->blend_src = Q3Shader::BLEND_GL_DST_COLOR;
curMap->blend_dest = Q3Shader::BLEND_GL_ZERO;
}
else if (blend_src == "blend") {
curMap->blend_src = Q3Shader::BLEND_GL_SRC_ALPHA;
curMap->blend_dest = Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA;
}
else {
curMap->blend_src = StringToBlendFunc(blend_src);
curMap->blend_dest = StringToBlendFunc(GetNextToken(buff));
}
}
// 'alphafunc' - Alpha testing mode
else if (TokenMatchI(buff,"alphafunc",9)) {
const std::string at = GetNextToken(buff);
if (at == "GT0") {
curMap->alpha_test = Q3Shader::AT_GT0;
}
else if (at == "LT128") {
curMap->alpha_test = Q3Shader::AT_LT128;
}
else if (at == "GE128") {
curMap->alpha_test = Q3Shader::AT_GE128;
}
}
else if (*buff == '}') {
++buff;
// close this map section
curMap = NULL;
break;
}
}
}
else if (*buff == '}') {
++buff;
curData = NULL;
break;
}
// 'cull' specifies culling behaviour for the model
else if (TokenMatchI(buff,"cull",4)) {
SkipSpaces(&buff);
if (!ASSIMP_strincmp(buff,"back",4)) {
curData->cull = Q3Shader::CULL_CCW;
} else if (!ASSIMP_strincmp(buff,"front",5)) {
curData->cull = Q3Shader::CULL_CW;
} else if (!ASSIMP_strincmp(buff,"none",4) || !ASSIMP_strincmp(buff,"disable",7)) {
curData->cull = Q3Shader::CULL_NONE;
} else {
ASSIMP_LOG_ERROR("Q3Shader: Unrecognized cull mode");
}
}
}
} else {
// add new section
fill.blocks.push_back(Q3Shader::ShaderDataBlock());
curData = &fill.blocks.back();
// get the name of this section
curData->name = GetNextToken(buff);
}
}
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x40(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2e4353(%rip), %rsi # 0x5cf70a
leaq 0x2e434e(%rip), %rdx # 0x5cf70c
leaq 0x70(%rsp), %rdi
callq 0x209290
movq (%rbx), %rsi
movq 0x70(%rsp), %rdx
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, %r15
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x2eb3fe
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
testq %r15, %r15
je 0x2ebc97
callq 0x241234
movq %rax, %r14
leaq 0x2b5deb(%rip), %rsi # 0x5a1201
leaq 0x70(%rsp), %rdi
callq 0x2bfcba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x70(%rsp), %rdi
callq 0x1a61e0
leaq 0x78(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x1a5690
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x24114a
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2eb468
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x4c0b21(%rip), %rsi # 0x7abf90
leaq 0x70(%rsp), %rdi
callq 0x1a5d00
leaq 0xe0(%rsp), %rdi
callq 0x1a5ca0
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq %rax, %rbx
leaq 0x1(%rax), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x2f0256
movq 0x48(%rsp), %rsi
movq (%r15), %rax
movl $0x1, %ecx
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rdx
callq *0x10(%rax)
movq 0x48(%rsp), %rax
movb $0x0, (%rax,%rbx)
movq 0x48(%rsp), %rsi
leaq 0x2a1596(%rip), %rdi # 0x58ca6b
movl $0x20, %edx
callq 0x522870
movq 0x48(%rsp), %r14
movabsq $0x100003601, %r13 # imm = 0x100003601
movabsq $0x100002600, %r12 # imm = 0x100002600
movl $0x2401, %ebp # imm = 0x2401
movq $0x0, 0x10(%rsp)
leaq 0x80(%rsp), %r15
movq %r14, %rbx
leaq 0x98(%rsp), %r14
movzbl (%rbx), %eax
cmpq $0x20, %rax
ja 0x2eb536
btq %rax, %r12
jae 0x2eb52d
incq %rbx
jmp 0x2eb519
testq %rax, %rax
je 0x2ebc72
cmpl $0x7b, %eax
jne 0x2ebb3b
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2ebc5e
incq %rbx
addq $0x28, %rax
movq %rax, 0x60(%rsp)
movq %rbx, %r14
movzbl (%r14), %eax
cmpq $0x20, %rax
ja 0x2eb57a
btq %rax, %r12
jae 0x2eb571
incq %r14
jmp 0x2eb55c
testq %rax, %rax
je 0x2ebc36
cmpl $0x7b, %eax
je 0x2eb5d8
cmpl $0x7d, %eax
je 0x2ebc25
movl $0x4, %edx
leaq 0x2b5ce4(%rip), %rdi # 0x5a1278
movq %r14, %rsi
callq 0x1a61b0
testl %eax, %eax
jne 0x2ebb13
movzbl 0x4(%r14), %eax
cmpq $0x20, %rax
ja 0x2ebb13
btq %rax, %r13
jae 0x2ebb13
addq $0x5, %r14
movzbl (%r14), %eax
cmpl $0x20, %eax
je 0x2eb5d3
cmpl $0x9, %eax
jne 0x2eba63
incq %r14
jmp 0x2eb5c1
movq %r15, 0x70(%rsp)
xorl %eax, %eax
movq %rax, 0x78(%rsp)
movb $0x0, 0x80(%rsp)
movq %rax, 0x90(%rsp)
movl $0x0, 0x98(%rsp)
movl $0x40, %edi
callq 0x1a5230
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x70(%rsp), %rdx
cmpq %r15, %rdx
je 0x2eb630
movq %rdx, 0x10(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x2eb637
movups (%r15), %xmm0
movups %xmm0, (%rcx)
movq 0x78(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %r15, 0x70(%rsp)
movq $0x0, 0x78(%rsp)
movb $0x0, 0x80(%rsp)
leaq 0x90(%rsp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, 0x38(%rax)
movq (%rdx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x1a5360
movq 0x10(%rsp), %rax
incq 0x38(%rax)
movq 0x70(%rsp), %rdi
cmpq %r15, %rdi
je 0x2eb69b
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
incq %r14
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
addq $0x10, %rax
movq %rax, 0x68(%rsp)
movzbl (%r14), %r15d
cmpq $0x20, %r15
ja 0x2eb6d3
btq %r15, %r12
jae 0x2eb6ca
incq %r14
jmp 0x2eb6b5
testq %r15, %r15
je 0x2ebadc
movl $0x3, %edx
leaq 0x262289(%rip), %rdi # 0x54d968
movq %r14, %rsi
callq 0x1a61b0
testl %eax, %eax
je 0x2eb74a
movl $0x8, %edx
leaq 0x2b5b54(%rip), %rdi # 0x5a124b
movq %r14, %rsi
callq 0x1a61b0
testl %eax, %eax
je 0x2eb762
movl $0x9, %edx
leaq 0x2b5b45(%rip), %rdi # 0x5a1254
movq %r14, %rsi
callq 0x1a61b0
testl %eax, %eax
je 0x2eb81c
movl $0x9, %edx
leaq 0x2b5b33(%rip), %rdi # 0x5a125e
movq %r14, %rsi
callq 0x1a61b0
testl %eax, %eax
je 0x2eb8fa
cmpb $0x7d, %r15b
jne 0x2eb7f4
jmp 0x2ebad9
movzbl 0x3(%r14), %ecx
cmpq $0x20, %rcx
ja 0x2eb6eb
movl $0x4, %eax
btq %rcx, %r13
jb 0x2eb778
jmp 0x2eb6eb
movzbl 0x8(%r14), %ecx
cmpq $0x20, %rcx
ja 0x2eb703
movl $0x9, %eax
btq %rcx, %r13
jae 0x2eb703
addq %rax, %r14
movq %r14, %rsi
leaq 0x80(%rsp), %r15
movzbl (%rsi), %eax
cmpq $0x20, %rax
ja 0x2eb79a
btq %rax, %r12
jae 0x2eb79a
incq %rsi
jmp 0x2eb786
movq %rsi, %r14
cmpb $0x20, %al
ja 0x2eb7aa
movzbl %al, %eax
btq %rax, %r13
jb 0x2eb7b3
movb 0x1(%r14), %al
incq %r14
jmp 0x2eb79d
movq %r15, 0x70(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x209290
movq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x1a58d0
movq 0x70(%rsp), %rdi
cmpq %r15, %rdi
je 0x2eb7f4
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2eb7f4
incq %r14
movzbl (%r14), %eax
cmpl $0xd, %eax
ja 0x2eb7f1
btl %eax, %ebp
jae 0x2eb7f1
jmp 0x2eb80b
movb 0x1(%r14), %al
incq %r14
cmpb $0xd, %al
je 0x2eb804
movzbl %al, %eax
cmpl $0xa, %eax
je 0x2eb804
jmp 0x2eb6b5
movzbl 0x9(%r14), %eax
cmpq $0x20, %rax
ja 0x2eb71f
btq %rax, %r13
jae 0x2eb71f
addq $0xa, %r14
movq %r14, %rsi
leaq 0x80(%rsp), %r15
movzbl (%rsi), %eax
cmpq $0x20, %rax
ja 0x2eb858
btq %rax, %r12
jae 0x2eb858
incq %rsi
jmp 0x2eb844
movq %rsi, %r14
cmpb $0x20, %al
ja 0x2eb868
movzbl %al, %eax
btq %rax, %r13
jb 0x2eb871
movb 0x1(%r14), %al
incq %r14
jmp 0x2eb85b
movq %r15, 0x70(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x209290
movq %rbx, %rdi
leaq 0x2b2f68(%rip), %rsi # 0x59e7f8
callq 0x1a60c0
testl %eax, %eax
je 0x2eb9af
movq %rbx, %rdi
leaq 0x2808a6(%rip), %rsi # 0x56c14d
callq 0x1a60c0
testl %eax, %eax
je 0x2eba2d
movq %rbx, %rdi
leaq 0x2be244(%rip), %rsi # 0x5a9b02
callq 0x1a60c0
testl %eax, %eax
je 0x2eba4b
movq %rbx, %rdi
callq 0x2eb280
movq 0x18(%rsp), %rcx
movl %eax, 0x30(%rcx)
movq %r14, %rsi
movzbl (%rsi), %eax
cmpq $0x20, %rax
ja 0x2eb9c5
btq %rax, %r12
jae 0x2eb9c5
incq %rsi
jmp 0x2eb8de
movzbl 0x9(%r14), %eax
cmpq $0x20, %rax
ja 0x2eb73b
btq %rax, %r13
jae 0x2eb73b
addq $0xa, %r14
movq %r14, %rsi
leaq 0x80(%rsp), %r15
movzbl (%rsi), %eax
cmpq $0x20, %rax
ja 0x2eb936
btq %rax, %r12
jae 0x2eb936
incq %rsi
jmp 0x2eb922
movq %rsi, %r14
cmpb $0x20, %al
ja 0x2eb946
movzbl %al, %eax
btq %rax, %r13
jb 0x2eb94f
movb 0x1(%r14), %al
incq %r14
jmp 0x2eb939
movq %r15, 0x70(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x209290
movq %rbx, %rdi
leaq 0x2b58fa(%rip), %rsi # 0x5a1268
callq 0x1a60c0
testl %eax, %eax
je 0x2eb9be
movq %rbx, %rdi
leaq 0x2b58eb(%rip), %rsi # 0x5a126c
callq 0x1a60c0
testl %eax, %eax
je 0x2eba39
movq %rbx, %rdi
leaq 0x2b58da(%rip), %rsi # 0x5a1272
callq 0x1a60c0
testl %eax, %eax
jne 0x2eb7d5
movl $0x3, %eax
jmp 0x2eba3e
movabsq $0x100000001, %rax # imm = 0x100000001
jmp 0x2eba55
movl $0x1, %eax
jmp 0x2eba3e
movq %rsi, %r14
cmpb $0x20, %al
ja 0x2eb9d5
movzbl %al, %eax
btq %rax, %r13
jb 0x2eb9de
movb 0x1(%r14), %al
incq %r14
jmp 0x2eb9c8
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x209290
movq %rbx, %rdi
callq 0x2eb280
movq 0x18(%rsp), %rcx
movl %eax, 0x34(%rcx)
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2eb7d5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2eb7d5
movabsq $0x200000003, %rax # imm = 0x200000003
jmp 0x2eba55
movl $0x2, %eax
movq 0x18(%rsp), %rcx
movl %eax, 0x38(%rcx)
jmp 0x2eb7d5
movabsq $0x600000005, %rax # imm = 0x600000005
movq 0x18(%rsp), %rcx
movq %rax, 0x30(%rcx)
jmp 0x2eb7d5
movl $0x4, %edx
movq %r14, %rdi
leaq 0x2f1990(%rip), %rsi # 0x5dd402
callq 0x1a61b0
testl %eax, %eax
je 0x2ebae6
movl $0x5, %edx
movq %r14, %rdi
leaq 0x2f196d(%rip), %rsi # 0x5dd3f7
callq 0x1a61b0
testl %eax, %eax
je 0x2ebb02
movl $0x4, %edx
movq %r14, %rdi
leaq 0x2b57db(%rip), %rsi # 0x5a127d
callq 0x1a61b0
testl %eax, %eax
je 0x2ebaf4
movl $0x7, %edx
movq %r14, %rdi
leaq 0x2b57c8(%rip), %rsi # 0x5a1282
callq 0x1a61b0
testl %eax, %eax
je 0x2ebaf4
callq 0x241234
movq %rax, %rdi
leaq 0x2b57b8(%rip), %rsi # 0x5a128a
callq 0x2411ba
jmp 0x2ebb13
incq %r14
leaq 0x80(%rsp), %r15
jmp 0x2ebb13
movq 0x10(%rsp), %rax
movl $0x2, 0x20(%rax)
jmp 0x2ebb13
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
jmp 0x2ebb13
movq 0x10(%rsp), %rax
movl $0x1, 0x20(%rax)
jmp 0x2ebb13
incq %r14
movzbl (%r14), %eax
cmpl $0xd, %eax
ja 0x2ebb10
btl %eax, %ebp
jae 0x2ebb10
jmp 0x2ebb2a
movb 0x1(%r14), %al
incq %r14
cmpb $0xd, %al
je 0x2ebb23
movzbl %al, %eax
cmpl $0xa, %eax
je 0x2ebb23
jmp 0x2eb55c
movq %r15, 0x70(%rsp)
xorl %eax, %eax
movq %rax, 0x78(%rsp)
movb $0x0, 0x80(%rsp)
movl $0x1, 0x90(%rsp)
movq %r14, 0xa0(%rsp)
movq %r14, 0x98(%rsp)
movq %rax, 0xa8(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, %rsi
leaq 0x70(%rsp), %rdx
callq 0x2f0464
movq %r14, %rdi
callq 0x2f0314
movq 0x70(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ebba6
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movzbl (%rbx), %eax
cmpq $0x20, %rax
ja 0x2ebbc3
btq %rax, %r12
jae 0x2ebbc3
incq %rbx
jmp 0x2ebbaf
addq $0x10, %rcx
movq %rcx, 0x10(%rsp)
movq %rbx, %r14
cmpb $0x20, %al
ja 0x2ebbdc
movzbl %al, %eax
btq %rax, %r13
jb 0x2ebbe5
movb 0x1(%r14), %al
incq %r14
jmp 0x2ebbcf
movq %r15, 0x70(%rsp)
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x209290
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1a58d0
movq 0x70(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ebc36
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2ebc36
incq %r14
movq $0x0, 0x10(%rsp)
jmp 0x2ebc36
incq %r14
movzbl (%r14), %eax
cmpl $0xd, %eax
ja 0x2ebc33
btl %eax, %ebp
jae 0x2ebc33
jmp 0x2ebc4d
movb 0x1(%r14), %al
incq %r14
cmpb $0xd, %al
je 0x2ebc46
movzbl %al, %eax
cmpl $0xa, %eax
je 0x2ebc46
jmp 0x2eb50e
callq 0x241234
leaq 0x2b55b3(%rip), %rsi # 0x5a121d
movq %rax, %rdi
callq 0x2411ba
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x2ebc89
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x8(%rsp), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
testq %r15, %r15
setne %al
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ebdb9
jmp 0x2ebdb9
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2f02b6
jmp 0x2ebdbc
jmp 0x2ebcf1
jmp 0x2ebcf1
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ebd3c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2ebd3c
jmp 0x2ebcf1
movq %rax, %rbx
jmp 0x2ebdd8
jmp 0x2ebdb9
movq %rax, %rbx
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x2ebde1
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2ebde1
movq %rax, %rbx
jmp 0x2ebde1
jmp 0x2ebdb9
movq %rax, %rbx
movq 0x4c024d(%rip), %rsi # 0x7abf90
leaq 0x70(%rsp), %rdi
callq 0x1a5d00
leaq 0xe0(%rsp), %rdi
callq 0x1a5ca0
jmp 0x2ebdd8
jmp 0x2ebd7f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2ebd82
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2ebd82
movq %rax, %rbx
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
jne 0x2ebda3
jmp 0x2ebdbc
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ebdbc
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x2ebdbc
jmp 0x2ebdb9
jmp 0x2ebdb9
movq %rax, %rbx
movq 0x8(%rsp), %r15
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x2ebdd8
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/MD3/MD3Loader.cpp |
Assimp::MD3Importer::~MD3Importer() | MD3Importer::~MD3Importer()
{} | pushq %rbx
movq %rdi, %rbx
leaq 0x3f32c3(%rip), %rax # 0x6df7b0
movq %rax, (%rdi)
movq 0x120(%rdi), %rdi
leaq 0x130(%rbx), %rax
cmpq %rax, %rdi
je 0x2ec50e
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0x100(%rbx), %rdi
leaq 0x110(%rbx), %rax
cmpq %rax, %rdi
je 0x2ec52c
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0xe0(%rbx), %rdi
leaq 0xf0(%rbx), %rax
cmpq %rax, %rdi
je 0x2ec54a
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x2ec568
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x2ec586
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
popq %rbx
jmp 0x247876
nop
| /hbina[P]fatuous/thirdparty/assimp/code/MD3/MD3Loader.cpp |
Assimp::MD3Importer::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const | bool MD3Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
{
const std::string extension = GetExtension(pFile);
if (extension == "md3")
return true;
// if check for extension is not enough, check for the magic tokens
if (!extension.length() || checkSig) {
uint32_t tokens[1];
tokens[0] = AI_MD3_MAGIC_NUMBER_LE;
return CheckMagicToken(pIOHandler,pFile,tokens,1);
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x24818a
leaq 0x2b5099(%rip), %rsi # 0x5a1667
movq %r15, %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x2ec614
cmpq $0x0, 0x10(%rsp)
setne %al
xorb $0x1, %bpl
testb %bpl, %al
jne 0x2ec618
leaq 0x4(%rsp), %rdx
movl $0x33504449, (%rdx) # imm = 0x33504449
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
movl $0x4, %r9d
callq 0x24821c
movl %eax, %ebx
jmp 0x2ec61a
movb $0x1, %bl
jmp 0x2ec61a
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ec635
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ec660
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/MD3/MD3Loader.cpp |
Assimp::MD3Importer::ValidateHeaderOffsets() | void MD3Importer::ValidateHeaderOffsets()
{
// Check magic number
if (pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE &&
pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE)
throw DeadlyImportError( "Invalid MD3 file: Magic bytes not found");
// Check file format version
if (pcHeader->VERSION > 15)
ASSIMP_LOG_WARN( "Unsupported MD3 file version. Continuing happily ...");
// Check some offset values whether they are valid
if (!pcHeader->NUM_SURFACES)
throw DeadlyImportError( "Invalid md3 file: NUM_SURFACES is 0");
if (pcHeader->OFS_FRAMES >= fileSize || pcHeader->OFS_SURFACES >= fileSize ||
pcHeader->OFS_EOF > fileSize) {
throw DeadlyImportError("Invalid MD3 header: some offsets are outside the file");
}
if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) {
throw DeadlyImportError("Invalid MD3 header: too many surfaces, would overflow");
}
if (pcHeader->OFS_SURFACES + pcHeader->NUM_SURFACES * sizeof(MD3::Surface) >= fileSize) {
throw DeadlyImportError("Invalid MD3 header: some surfaces are outside the file");
}
if (pcHeader->NUM_FRAMES <= configFrameID )
throw DeadlyImportError("The requested frame is not existing the file");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0xc8(%rdi), %rax
movl (%rax), %ecx
cmpl $0x33504449, %ecx # imm = 0x33504449
je 0x2ec692
cmpl $0x49445033, %ecx # imm = 0x49445033
jne 0x2ec8ff
cmpl $0x10, 0x4(%rax)
jb 0x2ec6b3
callq 0x241234
leaq 0x2b4d16(%rip), %rsi # 0x5a13ba
movq %rax, %rdi
callq 0x241182
movq 0xc8(%rbx), %rax
movl 0x54(%rax), %ecx
testq %rcx, %rcx
je 0x2ec76e
movl 0xd8(%rbx), %edx
cmpl %edx, 0x5c(%rax)
jae 0x2ec709
movl 0x64(%rax), %esi
cmpl %edx, %esi
jae 0x2ec709
cmpl %edx, 0x68(%rax)
ja 0x2ec709
cmpl $0x25ed0a, %ecx # imm = 0x25ED0A
jae 0x2ec7d3
imulq $0x6c, %rcx, %rcx
addq %rcx, %rsi
cmpq %rdx, %rsi
jae 0x2ec838
movl 0x4c(%rax), %eax
cmpl 0x78(%rbx), %eax
jbe 0x2ec89d
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 0x2b4ced(%rip), %rsi # 0x5a1413
leaq 0x2b4d1b(%rip), %rdx # 0x5a1448
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f0fea(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f0fb6(%rip), %rsi # 0x6dd710
movq 0x4bf7ff(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2ec95f
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b4c64(%rip), %rsi # 0x5a13ef
leaq 0x2b4c80(%rip), %rdx # 0x5a1412
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f0f85(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f0f51(%rip), %rsi # 0x6dd710
movq 0x4bf79a(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2ec95f
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b4c59(%rip), %rsi # 0x5a1449
leaq 0x2b4c87(%rip), %rdx # 0x5a147e
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f0f20(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f0eec(%rip), %rsi # 0x6dd710
movq 0x4bf735(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2ec95f
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b4c2a(%rip), %rsi # 0x5a147f
leaq 0x2b4c59(%rip), %rdx # 0x5a14b5
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f0ebb(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f0e87(%rip), %rsi # 0x6dd710
movq 0x4bf6d0(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2ec95f
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b4764(%rip), %rsi # 0x5a101e
leaq 0x2b4789(%rip), %rdx # 0x5a104a
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f0e56(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f0e22(%rip), %rsi # 0x6dd710
movq 0x4bf66b(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2ec95f
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b4a76(%rip), %rsi # 0x5a1392
leaq 0x2b4a96(%rip), %rdx # 0x5a13b9
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f0df4(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f0dc0(%rip), %rsi # 0x6dd710
movq 0x4bf609(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2ec973
jmp 0x2ec994
jmp 0x2ec973
jmp 0x2ec994
jmp 0x2ec973
jmp 0x2ec994
jmp 0x2ec973
jmp 0x2ec994
jmp 0x2ec973
jmp 0x2ec994
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ec98d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2ec997
jmp 0x2ec99f
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/MD3/MD3Loader.cpp |
Assimp::MD3Importer::ValidateSurfaceHeaderOffsets(Assimp::MD3::Surface const*) | void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface* pcSurf)
{
// Calculate the relative offset of the surface
const int32_t ofs = int32_t((const unsigned char*)pcSurf-this->mBuffer);
// Check whether all data chunks are inside the valid range
if (pcSurf->OFS_TRIANGLES + ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle) > fileSize ||
pcSurf->OFS_SHADERS + ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader) > fileSize ||
pcSurf->OFS_ST + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord) > fileSize ||
pcSurf->OFS_XYZNORMAL + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex) > fileSize) {
throw DeadlyImportError("Invalid MD3 surface header: some offsets are outside the file");
}
// Check whether all requirements for Q3 files are met. We don't
// care, but probably someone does.
if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES) {
ASSIMP_LOG_WARN("MD3: Quake III triangle limit exceeded");
}
if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) {
ASSIMP_LOG_WARN("MD3: Quake III shader limit exceeded");
}
if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) {
ASSIMP_LOG_WARN("MD3: Quake III vertex limit exceeded");
}
if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) {
ASSIMP_LOG_WARN("MD3: Quake III frame limit exceeded");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl 0xd0(%rdi), %eax
movl %ebx, %ecx
subl %eax, %ecx
movl 0x58(%rsi), %edx
addl %ecx, %edx
movl 0x54(%rsi), %eax
leaq (%rax,%rax,2), %rsi
leaq (%rdx,%rsi,4), %rdx
movl 0xd8(%rdi), %esi
cmpq %rsi, %rdx
ja 0x2ecab0
movl 0x5c(%rbx), %edi
addl %ecx, %edi
movl 0x4c(%rbx), %edx
movq %rdx, %r8
shlq $0x6, %r8
leaq (%r8,%rdx,4), %r8
addq %rdi, %r8
cmpq %rsi, %r8
ja 0x2ecab0
movl 0x60(%rbx), %r8d
addl %ecx, %r8d
movl 0x50(%rbx), %edi
leaq (%r8,%rdi,8), %r8
cmpq %rsi, %r8
ja 0x2ecab0
shlq $0x3, %rdi
addl 0x64(%rbx), %ecx
addq %rdi, %rcx
cmpq %rsi, %rcx
ja 0x2ecab0
cmpl $0x2001, %eax # imm = 0x2001
jb 0x2eca45
callq 0x241234
leaq 0x2b4aba(%rip), %rsi # 0x5a14f4
movq %rax, %rdi
callq 0x241182
movl 0x4c(%rbx), %edx
cmpl $0x101, %edx # imm = 0x101
jb 0x2eca61
callq 0x241234
leaq 0x2b4ac2(%rip), %rsi # 0x5a151b
movq %rax, %rdi
callq 0x241182
cmpl $0x1001, 0x50(%rbx) # imm = 0x1001
jb 0x2eca7e
callq 0x241234
leaq 0x2b4aca(%rip), %rsi # 0x5a1540
movq %rax, %rdi
callq 0x241182
cmpl $0x401, 0x48(%rbx) # imm = 0x401
jb 0x2ecaa5
callq 0x241234
leaq 0x2b4ad2(%rip), %rsi # 0x5a1565
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x241182
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 0x2b49e9(%rip), %rsi # 0x5a14b6
leaq 0x2b4a1f(%rip), %rdx # 0x5a14f3
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3f0c43(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3f0c0f(%rip), %rsi # 0x6dd710
movq 0x4bf458(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ecb2a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2ecb34
jmp 0x2ecb3c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/MD3/MD3Loader.cpp |
RemoveSingleNodeFromList(aiNode*) | void RemoveSingleNodeFromList(aiNode* nd)
{
if (!nd || nd->mNumChildren || !nd->mParent)return;
aiNode* par = nd->mParent;
for (unsigned int i = 0; i < par->mNumChildren;++i) {
if (par->mChildren[i] == nd) {
--par->mNumChildren;
for (;i < par->mNumChildren;++i) {
par->mChildren[i] = par->mChildren[i+1];
}
delete nd;
break;
}
}
} | pushq %rbx
testq %rdi, %rdi
je 0x2ed61a
movq %rdi, %rbx
cmpl $0x0, 0x450(%rdi)
je 0x2ed61c
popq %rbx
retq
movq 0x448(%rbx), %rax
testq %rax, %rax
je 0x2ed61a
movl 0x450(%rax), %edx
testq %rdx, %rdx
je 0x2ed61a
movq 0x458(%rax), %rsi
xorl %ecx, %ecx
cmpq %rbx, (%rsi,%rcx,8)
je 0x2ed64c
incq %rcx
cmpq %rcx, %rdx
jne 0x2ed63c
jmp 0x2ed61a
decl %edx
movl %edx, 0x450(%rax)
cmpl %ecx, %edx
jbe 0x2ed67a
movq 0x458(%rax), %rdx
movq 0x8(%rdx,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
leaq 0x1(%rcx), %rdx
movl 0x450(%rax), %esi
movq %rdx, %rcx
cmpq %rsi, %rdx
jb 0x2ed658
movq %rbx, %rdi
callq 0x240468
movl $0x478, %esi # imm = 0x478
movq %rbx, %rdi
popq %rbx
jmp 0x1a5190
| /hbina[P]fatuous/thirdparty/assimp/code/MD3/MD3Loader.cpp |
Assimp::MD5Importer::MD5Importer() | MD5Importer::MD5Importer()
: mIOHandler()
, mBuffer()
, fileSize()
, iLineNumber()
, pScene()
, pIOHandler()
, bHadMD5Mesh()
, bHadMD5Anim()
, bHadMD5Camera()
, configNoAutoLoad (false)
{} | pushq %rbx
movq %rdi, %rbx
callq 0x2477f4
leaq 0x3ef178(%rip), %rax # 0x6df870
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x78(%rbx)
leaq 0x90(%rbx), %rcx
movq %rcx, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movb $0x0, 0x90(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0xb0(%rbx)
movl $0x0, 0xc0(%rbx)
popq %rbx
retq
| /hbina[P]fatuous/thirdparty/assimp/code/MD5/MD5Loader.cpp |
Assimp::MD5Importer::MakeDataUnique(Assimp::MD5::MeshDesc&) | void MD5Importer::MakeDataUnique (MD5::MeshDesc& meshSrc)
{
std::vector<bool> abHad(meshSrc.mVertices.size(),false);
// allocate enough storage to keep the output structures
const unsigned int iNewNum = static_cast<unsigned int>(meshSrc.mFaces.size()*3);
unsigned int iNewIndex = static_cast<unsigned int>(meshSrc.mVertices.size());
meshSrc.mVertices.resize(iNewNum);
// try to guess how much storage we'll need for new weights
const float fWeightsPerVert = meshSrc.mWeights.size() / (float)iNewIndex;
const unsigned int guess = (unsigned int)(fWeightsPerVert*iNewNum);
meshSrc.mWeights.reserve(guess + (guess >> 3)); // + 12.5% as buffer
for (FaceList::const_iterator iter = meshSrc.mFaces.begin(),iterEnd = meshSrc.mFaces.end();iter != iterEnd;++iter){
const aiFace& face = *iter;
for (unsigned int i = 0; i < 3;++i) {
if (face.mIndices[0] >= meshSrc.mVertices.size()) {
throw DeadlyImportError("MD5MESH: Invalid vertex index");
}
if (abHad[face.mIndices[i]]) {
// generate a new vertex
meshSrc.mVertices[iNewIndex] = meshSrc.mVertices[face.mIndices[i]];
face.mIndices[i] = iNewIndex++;
}
else abHad[face.mIndices[i]] = true;
}
// swap face order
std::swap(face.mIndices[0],face.mIndices[2]);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq 0x20(%rsi), %rsi
subq 0x18(%rbx), %rsi
leaq 0x18(%rbx), %r15
sarq $0x4, %rsi
leaq 0x8(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x25093c
movq 0x20(%rbx), %r12
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
shrq $0x4, %rax
leal (%rax,%rax,2), %r14d
subq 0x18(%rbx), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x2f4338
shrq $0x4, %r12
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x2, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
testq %rax, %rax
js 0x2f3570
cvtsi2ss %rax, %xmm0
jmp 0x2f3585
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movl %r12d, %eax
cvtsi2ss %rax, %xmm1
movl %r14d, %eax
cvtsi2ss %rax, %xmm2
divss %xmm1, %xmm0
mulss %xmm0, %xmm2
cvttss2si %xmm2, %rax
movl %eax, %esi
shrl $0x3, %esi
addl %eax, %esi
movq %rbx, %rdi
callq 0x2f436c
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rdx
cmpq %rdx, %rax
je 0x2f364d
xorl %esi, %esi
movq 0x8(%rax), %rcx
movl (%rcx), %r8d
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %r9
subq %rdi, %r9
sarq $0x4, %r9
cmpq %r8, %r9
jbe 0x2f3671
movl (%rcx,%rsi,4), %ecx
movq 0x28(%rsp), %r8
movl $0x1, %r9d
shlq %cl, %r9
movl %ecx, %r10d
shrl $0x6, %r10d
movq (%r8,%r10,8), %r11
btq %rcx, %r11
jae 0x2f3626
shlq $0x4, %rcx
movl %r12d, %r8d
shlq $0x4, %r8
movups (%rdi,%rcx), %xmm0
movups %xmm0, (%rdi,%r8)
movq 0x8(%rax), %rcx
movl %r12d, (%rcx,%rsi,4)
incl %r12d
jmp 0x2f362d
orq %r11, %r9
movq %r9, (%r8,%r10,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x2f35c4
movq 0x8(%rax), %rcx
movl (%rcx), %esi
movl 0x8(%rcx), %edi
movl %edi, (%rcx)
movl %esi, 0x8(%rcx)
addq $0x10, %rax
jmp 0x2f35b9
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2f3664
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2ae4dd(%rip), %rsi # 0x5a1b6b
leaq 0x2ae4f3(%rip), %rdx # 0x5a1b88
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3ea082(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3ea04e(%rip), %rsi # 0x6dd710
movq 0x4b8897(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x2f36d3
movq %rax, %r14
jmp 0x2f3704
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f36f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2f36fc
jmp 0x2f3704
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2f371b
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/MD5/MD5Loader.cpp |
Assimp::MD5Importer::AttachChilds_Mesh(int, aiNode*, std::vector<Assimp::MD5::BoneDesc, std::allocator<Assimp::MD5::BoneDesc>>&) | void MD5Importer::AttachChilds_Mesh(int iParentID,aiNode* piParent, BoneList& bones)
{
ai_assert(NULL != piParent && !piParent->mNumChildren);
// First find out how many children we'll have
for (int i = 0; i < (int)bones.size();++i) {
if (iParentID != i && bones[i].mParentIndex == iParentID) {
++piParent->mNumChildren;
}
}
if (piParent->mNumChildren) {
piParent->mChildren = new aiNode*[piParent->mNumChildren];
for (int i = 0; i < (int)bones.size();++i) {
// (avoid infinite recursion)
if (iParentID != i && bones[i].mParentIndex == iParentID) {
aiNode* pc;
// setup a new node
*piParent->mChildren++ = pc = new aiNode();
pc->mName = aiString(bones[i].mName);
pc->mParent = piParent;
// get the transformation matrix from rotation and translational components
aiQuaternion quat;
MD5::ConvertQuaternion ( bones[i].mRotationQuat, quat );
bones[i].mTransform = aiMatrix4x4 ( quat.GetMatrix());
bones[i].mTransform.a4 = bones[i].mPositionXYZ.x;
bones[i].mTransform.b4 = bones[i].mPositionXYZ.y;
bones[i].mTransform.c4 = bones[i].mPositionXYZ.z;
// store it for later use
pc->mTransformation = bones[i].mInvTransform = bones[i].mTransform;
bones[i].mInvTransform.Inverse();
// the transformations for each bone are absolute, so we need to multiply them
// with the inverse of the absolute matrix of the parent joint
if (-1 != iParentID) {
pc->mTransformation = bones[iParentID].mInvTransform * pc->mTransformation;
}
// add children to this node, too
AttachChilds_Mesh( i, pc, bones);
}
}
// undo offset computations
piParent->mChildren -= piParent->mNumChildren;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp # imm = 0x488
movq %rdi, 0x48(%rsp)
testq %rdx, %rdx
je 0x2f3db4
movq %rdx, %r15
cmpl $0x0, 0x450(%rdx)
jne 0x2f3db4
movq (%rcx), %rax
movq 0x8(%rcx), %r9
movq %r9, %rdx
subq %rax, %rdx
shrq $0x2, %rdx
imull $0x9916f6a5, %edx, %edx # imm = 0x9916F6A5
testl %edx, %edx
jle 0x2f3da2
movl %esi, %ebx
xorl %edx, %edx
movl $0x404, %r10d # imm = 0x404
xorl %edi, %edi
cmpq %rdi, %rbx
je 0x2f3799
cmpl %esi, (%rax,%r10)
jne 0x2f3799
incl %edx
movl %edx, 0x450(%r15)
movq (%rcx), %rax
movq 0x8(%rcx), %r9
incq %rdi
movq %r9, %r8
subq %rax, %r8
shrq $0x2, %r8
imull $0x9916f6a5, %r8d, %r8d # imm = 0x9916F6A5
movslq %r8d, %r8
addq $0x4b4, %r10 # imm = 0x4B4
cmpq %r8, %rdi
jl 0x2f377e
testl %edx, %edx
je 0x2f3da2
movl %esi, 0xc(%rsp)
movq %rcx, %r12
movl %edx, %r14d
leaq (,%r14,8), %rdi
callq 0x1a57a0
movq %rax, 0x458(%r15)
movq (%r12), %rcx
movq %r12, 0x10(%rsp)
movq 0x8(%r12), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
shrq $0x2, %rsi
imull $0x9916f6a5, %esi, %esi # imm = 0x9916F6A5
testl %esi, %esi
jle 0x2f3d94
movq %r15, 0x18(%rsp)
movl 0xc(%rsp), %r14d
movslq %r14d, %rax
imulq $0x4b4, %rbx, %rsi # imm = 0x4B4
imulq $0x4b4, %rax, %rax # imm = 0x4B4
movq %rax, 0x38(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq 0x10(%rsp), %rbx
movq %rsi, 0x40(%rsp)
cmpq %rbp, %rsi
je 0x2f3d5c
cmpl %r14d, 0x404(%rcx,%rbp)
jne 0x2f3d5c
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2402f8
movq 0x18(%rsp), %rdx
movq 0x458(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x458(%rdx)
movq %r15, (%rax)
movq (%rbx), %r14
leaq (%r14,%rbp), %r12
addq $0x4, %r12
movl -0x4(%r12), %ebx
movl $0x3ff, %eax # imm = 0x3FF
cmpl %eax, %ebx
cmovael %eax, %ebx
movl %ebx, 0x84(%rsp)
leaq 0x88(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1a5110
xorl %eax, %eax
movb %al, 0x88(%rsp,%rbx)
movl %ebx, (%r15)
movq %r15, %rdi
addq $0x4, %rdi
leaq 0x88(%rsp), %rsi
movq %rbx, %rdx
callq 0x1a5110
xorl %eax, %eax
movb %al, 0x4(%r15,%rbx)
movq %r15, %rbx
movq 0x18(%rsp), %rax
movq %rax, 0x448(%r15)
movsd 0x410(%r12), %xmm10
movaps %xmm10, %xmm11
shufps $0x55, %xmm10, %xmm11 # xmm11 = xmm11[1,1],xmm10[1,1]
movss 0x418(%r12), %xmm9
movq 0x10(%rsp), %r12
movaps %xmm10, %xmm0
mulss %xmm10, %xmm0
movss 0x267c93(%rip), %xmm1 # 0x55b5b0
subss %xmm0, %xmm1
movaps %xmm11, %xmm0
mulss %xmm11, %xmm0
subss %xmm0, %xmm1
movaps %xmm9, %xmm7
mulss %xmm9, %xmm7
subss %xmm7, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
ja 0x2f3996
ucomiss 0x267cee(%rip), %xmm1 # 0x55b638
jb 0x2f3955
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
jmp 0x2f398b
movaps %xmm1, %xmm0
movaps %xmm9, 0x20(%rsp)
movaps %xmm10, 0x70(%rsp)
movaps %xmm11, 0x60(%rsp)
movaps %xmm7, 0x50(%rsp)
callq 0x1a6230
movaps 0x50(%rsp), %xmm7
movaps 0x60(%rsp), %xmm11
movaps 0x70(%rsp), %xmm10
movaps 0x20(%rsp), %xmm9
movq 0x10(%rsp), %rax
movq %rax, %r12
movq (%rax), %r14
movaps %xmm10, %xmm1
shufps $0xe1, %xmm10, %xmm1 # xmm1 = xmm1[1,0],xmm10[2,3]
movaps %xmm0, %xmm3
xorps 0x2678f7(%rip), %xmm3 # 0x55b2a0
movaps %xmm11, %xmm2
mulss %xmm11, %xmm2
addss %xmm7, %xmm2
addss %xmm2, %xmm2
movss 0x267bed(%rip), %xmm8 # 0x55b5b0
movaps %xmm8, %xmm5
subss %xmm2, %xmm5
movaps %xmm9, %xmm4
mulss %xmm0, %xmm4
movaps %xmm10, %xmm2
mulss %xmm11, %xmm2
subss %xmm4, %xmm2
addss %xmm2, %xmm2
movaps %xmm10, %xmm6
mulss %xmm10, %xmm6
addss %xmm6, %xmm7
addss %xmm7, %xmm7
movaps %xmm8, %xmm4
subss %xmm7, %xmm4
movaps %xmm10, %xmm7
mulss %xmm0, %xmm7
mulss %xmm9, %xmm11
addss %xmm7, %xmm11
addss %xmm11, %xmm11
movaps %xmm10, %xmm7
mulps %xmm10, %xmm7
shufps $0x55, %xmm7, %xmm7 # xmm7 = xmm7[1,1,1,1]
addss %xmm6, %xmm7
addss %xmm7, %xmm7
movaps %xmm8, %xmm6
subss %xmm7, %xmm6
movss %xmm5, 0x430(%r14,%rbp)
movaps %xmm10, %xmm5
movss %xmm9, %xmm5 # xmm5 = xmm9[0],xmm5[1,2,3]
unpcklps %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
mulps %xmm0, %xmm5
movaps %xmm9, %xmm3
movlhps %xmm10, %xmm3 # xmm3 = xmm3[0],xmm10[0]
shufps $0xe2, %xmm10, %xmm3 # xmm3 = xmm3[2,0],xmm10[2,3]
mulps %xmm1, %xmm3
addps %xmm5, %xmm3
addps %xmm3, %xmm3
movlps %xmm3, 0x434(%r14,%rbp)
movl $0x0, %eax
movl %eax, 0x43c(%r14,%rbp)
movss %xmm2, 0x440(%r14,%rbp)
movss %xmm4, 0x444(%r14,%rbp)
movss %xmm11, 0x448(%r14,%rbp)
movl %eax, 0x44c(%r14,%rbp)
mulps %xmm1, %xmm0
shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0]
mulps %xmm10, %xmm9
addps %xmm0, %xmm9
addps %xmm9, %xmm9
movlps %xmm9, 0x450(%r14,%rbp)
movss %xmm6, 0x458(%r14,%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x45c(%r14,%rbp)
movl $0x3f800000, 0x46c(%r14,%rbp) # imm = 0x3F800000
movq (%r12), %rax
movss 0x408(%rax,%rbp), %xmm0
movss %xmm0, 0x43c(%rax,%rbp)
movq (%r12), %rax
movss 0x40c(%rax,%rbp), %xmm0
movss %xmm0, 0x44c(%rax,%rbp)
movq (%r12), %rax
movss 0x410(%rax,%rbp), %xmm0
movss %xmm0, 0x45c(%rax,%rbp)
movq (%r12), %rax
movups 0x430(%rax,%rbp), %xmm0
movups 0x440(%rax,%rbp), %xmm1
movups 0x450(%rax,%rbp), %xmm2
movups 0x460(%rax,%rbp), %xmm3
movups %xmm3, 0x4a0(%rax,%rbp)
movups %xmm2, 0x490(%rax,%rbp)
movups %xmm1, 0x480(%rax,%rbp)
movups %xmm0, 0x470(%rax,%rbp)
movq %rbx, %r15
movups %xmm2, 0x424(%rbx)
movups %xmm0, 0x404(%rbx)
movups %xmm3, 0x434(%rbx)
movups %xmm1, 0x414(%rbx)
movq (%r12), %rdi
addq %rbp, %rdi
movl $0x470, %eax # imm = 0x470
addq %rax, %rdi
callq 0x25b84e
movl 0xc(%rsp), %r14d
cmpl $-0x1, %r14d
movq %r12, %rbx
je 0x2f3d3d
movq (%rbx), %rax
movq 0x38(%rsp), %rcx
movss 0x470(%rax,%rcx), %xmm4
movss 0x474(%rax,%rcx), %xmm5
movss 0x478(%rax,%rcx), %xmm6
movss 0x47c(%rax,%rcx), %xmm12
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
movups 0x404(%r15), %xmm2
movups 0x414(%r15), %xmm3
movups 0x424(%r15), %xmm1
movups 0x434(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
mulps %xmm3, %xmm5
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
mulps %xmm2, %xmm4
addps %xmm5, %xmm4
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm1, %xmm6
addps %xmm4, %xmm6
shufps $0x0, %xmm12, %xmm12 # xmm12 = xmm12[0,0,0,0]
mulps %xmm0, %xmm12
addps %xmm6, %xmm12
movss 0x484(%rax,%rcx), %xmm13
movss 0x480(%rax,%rcx), %xmm14
movss 0x488(%rax,%rcx), %xmm15
movss 0x48c(%rax,%rcx), %xmm0
movss 0x494(%rax,%rcx), %xmm11
movss 0x490(%rax,%rcx), %xmm10
movss 0x498(%rax,%rcx), %xmm8
movss 0x49c(%rax,%rcx), %xmm9
movss 0x4a4(%rax,%rcx), %xmm7
movss 0x4a0(%rax,%rcx), %xmm6
movss 0x4a8(%rax,%rcx), %xmm4
movss 0x4ac(%rax,%rcx), %xmm5
movups %xmm12, 0x404(%r15)
shufps $0x0, %xmm13, %xmm13 # xmm13 = xmm13[0,0,0,0]
mulps %xmm3, %xmm13
shufps $0x0, %xmm14, %xmm14 # xmm14 = xmm14[0,0,0,0]
mulps %xmm2, %xmm14
addps %xmm13, %xmm14
shufps $0x0, %xmm15, %xmm15 # xmm15 = xmm15[0,0,0,0]
mulps %xmm1, %xmm15
addps %xmm14, %xmm15
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps 0x20(%rsp), %xmm12
mulps %xmm12, %xmm0
addps %xmm15, %xmm0
movups %xmm0, 0x414(%r15)
shufps $0x0, %xmm11, %xmm11 # xmm11 = xmm11[0,0,0,0]
mulps %xmm3, %xmm11
shufps $0x0, %xmm10, %xmm10 # xmm10 = xmm10[0,0,0,0]
mulps %xmm2, %xmm10
addps %xmm11, %xmm10
shufps $0x0, %xmm8, %xmm8 # xmm8 = xmm8[0,0,0,0]
mulps %xmm1, %xmm8
addps %xmm10, %xmm8
shufps $0x0, %xmm9, %xmm9 # xmm9 = xmm9[0,0,0,0]
mulps %xmm12, %xmm9
addps %xmm8, %xmm9
movups %xmm9, 0x424(%r15)
shufps $0x0, %xmm7, %xmm7 # xmm7 = xmm7[0,0,0,0]
mulps %xmm3, %xmm7
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm2, %xmm6
addps %xmm7, %xmm6
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
mulps %xmm1, %xmm4
addps %xmm6, %xmm4
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
mulps %xmm12, %xmm5
addps %xmm4, %xmm5
movups %xmm5, 0x434(%r15)
movq 0x48(%rsp), %rdi
movl %r13d, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2f3724
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq 0x40(%rsp), %rsi
incq %r13
movq %rdx, %rax
subq %rcx, %rax
shrq $0x2, %rax
imull $0x9916f6a5, %eax, %eax # imm = 0x9916F6A5
cltq
addq $0x4b4, %rbp # imm = 0x4B4
cmpq %rax, %r13
jl 0x2f3837
movq 0x18(%rsp), %r15
movl 0x450(%r15), %r14d
movq 0x458(%r15), %rax
shlq $0x3, %r14
subq %r14, %rax
movq %rax, 0x458(%r15)
addq $0x488, %rsp # imm = 0x488
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2addce(%rip), %rdi # 0x5a1b89
leaq 0x2adcfe(%rip), %rsi # 0x5a1ac0
leaq 0x2addee(%rip), %rcx # 0x5a1bb7
movl $0x10b, %edx # imm = 0x10B
callq 0x1a5270
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %r15, %rdi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/MD5/MD5Loader.cpp |
Assimp::MD5Importer::AttachChilds_Anim(int, aiNode*, std::vector<Assimp::MD5::AnimBoneDesc, std::allocator<Assimp::MD5::AnimBoneDesc>>&, aiNodeAnim const**) | void MD5Importer::AttachChilds_Anim(int iParentID,aiNode* piParent, AnimBoneList& bones,const aiNodeAnim** node_anims)
{
ai_assert(NULL != piParent && !piParent->mNumChildren);
// First find out how many children we'll have
for (int i = 0; i < (int)bones.size();++i) {
if (iParentID != i && bones[i].mParentIndex == iParentID) {
++piParent->mNumChildren;
}
}
if (piParent->mNumChildren) {
piParent->mChildren = new aiNode*[piParent->mNumChildren];
for (int i = 0; i < (int)bones.size();++i) {
// (avoid infinite recursion)
if (iParentID != i && bones[i].mParentIndex == iParentID)
{
aiNode* pc;
// setup a new node
*piParent->mChildren++ = pc = new aiNode();
pc->mName = aiString(bones[i].mName);
pc->mParent = piParent;
// get the corresponding animation channel and its first frame
const aiNodeAnim** cur = node_anims;
while ((**cur).mNodeName != pc->mName)++cur;
aiMatrix4x4::Translation((**cur).mPositionKeys[0].mValue,pc->mTransformation);
pc->mTransformation = pc->mTransformation * aiMatrix4x4((**cur).mRotationKeys[0].mValue.GetMatrix()) ;
// add children to this node, too
AttachChilds_Anim( i, pc, bones,node_anims);
}
}
// undo offset computations
piParent->mChildren -= piParent->mNumChildren;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movq %rdi, 0x28(%rsp)
testq %rdx, %rdx
je 0x2f4300
movq %rdx, %r15
cmpl $0x0, 0x450(%rdx)
jne 0x2f4300
movq %rcx, %r12
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x4, %rdx
imull $0xc0fc0fc1, %edx, %edx # imm = 0xC0FC0FC1
testl %edx, %edx
jle 0x2f42ee
movq %r8, %rbp
movl %esi, %r10d
xorl %edx, %edx
movl $0x404, %r9d # imm = 0x404
xorl %edi, %edi
cmpq %rdi, %r10
je 0x2f3e6a
cmpl %esi, (%rax,%r9)
jne 0x2f3e6a
incl %edx
movl %edx, 0x450(%r15)
movq (%r12), %rax
movq 0x8(%r12), %rcx
incq %rdi
movq %rcx, %r8
subq %rax, %r8
shrq $0x4, %r8
imull $0xc0fc0fc1, %r8d, %r8d # imm = 0xC0FC0FC1
movslq %r8d, %r8
addq $0x410, %r9 # imm = 0x410
cmpq %r8, %rdi
jl 0x2f3e4d
testl %edx, %edx
je 0x2f42ee
movq %r10, 0x8(%rsp)
movl %esi, (%rsp)
movl %edx, %ebx
leaq (,%rbx,8), %rdi
callq 0x1a57a0
movq %rax, 0x458(%r15)
movq (%r12), %rcx
movq 0x8(%r12), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
shrq $0x4, %rsi
imull $0xc0fc0fc1, %esi, %esi # imm = 0xC0FC0FC1
testl %esi, %esi
jle 0x2f42e0
xorl %r13d, %r13d
movl (%rsp), %esi
movq 0x8(%rsp), %rdi
movq %r15, 0x20(%rsp)
movq %rbp, 0x10(%rsp)
movq %r12, 0x18(%rsp)
cmpq %rdi, %r13
je 0x2f42b4
imulq $0x410, %r13, %r14 # imm = 0x410
cmpl %esi, 0x404(%rcx,%r14)
jne 0x2f42b4
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %rbx
movq %rax, %rdi
callq 0x2402f8
movq 0x458(%r15), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x458(%r15)
movq %rbx, (%rax)
movq (%r12), %rax
leaq (%rax,%r14), %rsi
addq $0x4, %rsi
movl -0x4(%rsi), %r14d
movl $0x3ff, %eax # imm = 0x3FF
cmpl %eax, %r14d
cmovael %eax, %r14d
movl %r14d, 0x54(%rsp)
leaq 0x58(%rsp), %rdi
movq %r14, %rdx
callq 0x1a5110
xorl %ebp, %ebp
movb %bpl, 0x58(%rsp,%r14)
movl %r14d, (%rbx)
movq %rbx, %r12
addq $0x4, %r12
movq %r12, %rdi
leaq 0x58(%rsp), %rsi
movq %r14, %rdx
callq 0x1a5110
movb %bpl, 0x4(%rbx,%r14)
movq %r15, 0x448(%rbx)
movq 0x10(%rsp), %rbp
movq (%rbp), %r15
cmpl %r14d, (%r15)
jne 0x2f3fb2
leaq 0x4(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1a5c20
testl %eax, %eax
je 0x2f3fb8
addq $0x8, %rbp
jmp 0x2f3f96
movq 0x408(%r15), %rax
movl $0x3f800000, %ecx # imm = 0x3F800000
movl %ecx, 0x404(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x408(%rbx)
movl %ecx, 0x418(%rbx)
movups %xmm0, 0x41c(%rbx)
movl %ecx, 0x42c(%rbx)
movups %xmm0, 0x430(%rbx)
movl %ecx, 0x440(%rbx)
movss 0x8(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movss %xmm0, 0x410(%rbx)
movss 0xc(%rax), %xmm3
movss %xmm3, 0x420(%rbx)
movss 0x10(%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movss %xmm0, 0x430(%rbx)
movq 0x418(%r15), %rax
movss 0x14(%rax), %xmm1
movaps %xmm1, %xmm10
mulss %xmm1, %xmm10
movss 0x8(%rax), %xmm6
movaps %xmm1, %xmm7
mulss %xmm6, %xmm7
movsd 0xc(%rax), %xmm11
movaps %xmm11, %xmm13
shufps $0x55, %xmm11, %xmm13 # xmm13 = xmm13[1,1],xmm11[1,1]
movaps %xmm13, %xmm9
mulss %xmm13, %xmm9
movaps %xmm9, %xmm2
addss %xmm10, %xmm2
addss %xmm2, %xmm2
movss 0x26753d(%rip), %xmm4 # 0x55b5b0
movaps %xmm4, %xmm8
subss %xmm2, %xmm8
movaps %xmm11, %xmm5
mulss %xmm13, %xmm5
movaps %xmm5, %xmm12
subss %xmm7, %xmm12
movaps %xmm13, %xmm14
mulss %xmm6, %xmm14
movaps %xmm11, %xmm2
mulss %xmm1, %xmm2
addss %xmm14, %xmm2
addss %xmm7, %xmm5
movaps %xmm6, %xmm14
mulss %xmm11, %xmm14
movaps %xmm13, %xmm7
mulss %xmm1, %xmm7
xorps 0x2671df(%rip), %xmm13 # 0x55b2a0
unpcklps %xmm6, %xmm13 # xmm13 = xmm13[0],xmm6[0],xmm13[1],xmm6[1]
unpcklps %xmm11, %xmm6 # xmm6 = xmm6[0],xmm11[0],xmm6[1],xmm11[1]
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps %xmm11, %xmm1
movaps %xmm11, %xmm15
mulss %xmm11, %xmm15
addss %xmm15, %xmm10
addss %xmm10, %xmm10
movaps %xmm4, %xmm11
subss %xmm10, %xmm11
movaps 0x30(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
addss %xmm2, %xmm2
addss %xmm5, %xmm5
subss %xmm14, %xmm7
addss %xmm7, %xmm7
mulps %xmm13, %xmm6
addps %xmm6, %xmm1
addps %xmm1, %xmm1
addss %xmm9, %xmm15
addss %xmm15, %xmm15
subss %xmm15, %xmm4
movaps %xmm5, %xmm9
unpcklps %xmm12, %xmm9 # xmm9 = xmm9[0],xmm12[0],xmm9[1],xmm12[1]
mulps 0x2a27ae(%rip), %xmm9 # 0x5968e0
unpcklps %xmm11, %xmm5 # xmm5 = xmm5[0],xmm11[0],xmm5[1],xmm11[1]
xorps %xmm10, %xmm10
mulss %xmm10, %xmm11
movaps %xmm9, %xmm12
movss %xmm8, %xmm12 # xmm12 = xmm8[0],xmm12[1,2,3]
unpcklps %xmm11, %xmm8 # xmm8 = xmm8[0],xmm11[0],xmm8[1],xmm11[1]
addps %xmm9, %xmm8
movaps %xmm1, %xmm13
mulps 0x267244(%rip), %xmm13 # 0x55b3a0
addps %xmm13, %xmm8
mulss %xmm10, %xmm0
movaps %xmm7, %xmm14
mulss %xmm10, %xmm14
movaps %xmm2, %xmm15
addss %xmm14, %xmm15
movaps %xmm4, %xmm6
mulss %xmm10, %xmm6
addss %xmm6, %xmm15
addss %xmm0, %xmm15
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
addps %xmm8, %xmm0
mulss %xmm10, %xmm2
addss %xmm2, %xmm7
addss %xmm6, %xmm7
addss %xmm14, %xmm2
movlps %xmm0, 0x404(%rbx)
movss %xmm15, 0x40c(%rbx)
movss 0x4(%rsp), %xmm0
addss %xmm10, %xmm0
movss %xmm0, 0x410(%rbx)
mulps 0x2671d3(%rip), %xmm12 # 0x55b3a0
addps %xmm12, %xmm5
addps %xmm13, %xmm5
movaps %xmm3, %xmm0
mulss %xmm10, %xmm3
addss %xmm3, %xmm7
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
addps %xmm5, %xmm3
movlps %xmm3, 0x414(%rbx)
movss %xmm7, 0x41c(%rbx)
addss %xmm10, %xmm0
movss %xmm0, 0x420(%rbx)
movaps %xmm4, %xmm3
addss %xmm2, %xmm3
movlhps %xmm9, %xmm11 # xmm11 = xmm11[0],xmm9[0]
shufps $0xe2, %xmm9, %xmm11 # xmm11 = xmm11[2,0],xmm9[2,3]
movaps 0x40(%rsp), %xmm6
movaps %xmm6, %xmm0
mulss %xmm10, %xmm0
addss %xmm0, %xmm3
addps %xmm12, %xmm11
movaps %xmm1, %xmm5
addps %xmm11, %xmm5
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
addps %xmm5, %xmm0
shufps $0xd4, %xmm1, %xmm4 # xmm4 = xmm4[0,1],xmm1[1,3]
mulss %xmm10, %xmm1
addss %xmm11, %xmm1
shufps $0xd4, %xmm11, %xmm2 # xmm2 = xmm2[0,1],xmm11[1,3]
shufps $0xe2, %xmm4, %xmm4 # xmm4 = xmm4[2,0,2,3]
shufps $0xe2, %xmm2, %xmm2 # xmm2 = xmm2[2,0,2,3]
xorps %xmm5, %xmm5
mulps %xmm5, %xmm4
addps %xmm2, %xmm4
movlps %xmm0, 0x424(%rbx)
movss %xmm3, 0x42c(%rbx)
movaps %xmm6, %xmm0
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlhps %xmm4, %xmm0 # xmm0 = xmm0[0],xmm4[0]
addps %xmm5, %xmm0
movups %xmm0, 0x430(%rbx)
movl %ecx, 0x440(%rbx)
movq 0x28(%rsp), %rdi
movl %r13d, %esi
movq %rbx, %rdx
movq 0x18(%rsp), %r12
movq %r12, %rcx
movq 0x10(%rsp), %r8
callq 0x2f3dec
movq (%r12), %rcx
movq 0x8(%r12), %rdx
movq 0x20(%rsp), %r15
movl (%rsp), %esi
movq 0x8(%rsp), %rdi
incq %r13
movq %rdx, %rax
subq %rcx, %rax
shrq $0x4, %rax
imull $0xc0fc0fc1, %eax, %eax # imm = 0xC0FC0FC1
cltq
cmpq %rax, %r13
jl 0x2f3eee
movl 0x450(%r15), %ebx
movq 0x458(%r15), %rax
shlq $0x3, %rbx
subq %rbx, %rax
movq %rax, 0x458(%r15)
addq $0x458, %rsp # imm = 0x458
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ad882(%rip), %rdi # 0x5a1b89
leaq 0x2ad7b2(%rip), %rsi # 0x5a1ac0
leaq 0x2ad8e9(%rip), %rcx # 0x5a1bfe
movl $0x13e, %edx # imm = 0x13E
callq 0x1a5270
movq %rax, %r14
movl $0x478, %esi # imm = 0x478
movq %rbx, %rdi
callq 0x1a5190
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/MD5/MD5Loader.cpp |
Assimp::MD5::MD5Parser::ReportError(char const*, unsigned int) | AI_WONT_RETURN void MD5Parser::ReportError (const char* error, unsigned int line)
{
char szBuffer[1024];
::ai_snprintf(szBuffer, 1024, "[MD5] Line %u: %s",line,error);
throw DeadlyImportError(szBuffer);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movl %esi, %ecx
movq %rdi, %r8
leaq 0x2ad180(%rip), %rdx # 0x5a1f3f
leaq 0x20(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
xorl %eax, %eax
callq 0x1a5890
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x1a56a0
leaq (%rsp,%rax), %rdx
addq $0x20, %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x209290
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3e891f(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3e88eb(%rip), %rsi # 0x6dd710
movq 0x4b7134(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2f4e4d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x2f4e57
jmp 0x2f4e5f
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/MD5/MD5Parser.cpp |
Assimp::MDLImporter::BuildOutputAnims_3DGS_MDL7(Assimp::MDL::IntBone_MDL7 const**) | void MDLImporter::BuildOutputAnims_3DGS_MDL7(
const MDL::IntBone_MDL7** apcBonesOut)
{
ai_assert(NULL != apcBonesOut);
const MDL::Header_MDL7* const pcHeader = (const MDL::Header_MDL7*)mBuffer;
// one animation ...
aiAnimation* pcAnim = new aiAnimation();
for (uint32_t i = 0; i < pcHeader->bones_num;++i) {
if (!apcBonesOut[i]->pkeyPositions.empty()) {
// get the last frame ... (needn't be equal to pcHeader->frames_num)
for (size_t qq = 0; qq < apcBonesOut[i]->pkeyPositions.size();++qq) {
pcAnim->mDuration = std::max(pcAnim->mDuration, (double)
apcBonesOut[i]->pkeyPositions[qq].mTime);
}
++pcAnim->mNumChannels;
}
}
if (pcAnim->mDuration) {
pcAnim->mChannels = new aiNodeAnim*[pcAnim->mNumChannels];
unsigned int iCnt = 0;
for (uint32_t i = 0; i < pcHeader->bones_num;++i) {
if (!apcBonesOut[i]->pkeyPositions.empty()) {
const MDL::IntBone_MDL7* const intBone = apcBonesOut[i];
aiNodeAnim* const pcNodeAnim = pcAnim->mChannels[iCnt++] = new aiNodeAnim();
pcNodeAnim->mNodeName = aiString( intBone->mName );
// allocate enough storage for all keys
pcNodeAnim->mNumPositionKeys = (unsigned int)intBone->pkeyPositions.size();
pcNodeAnim->mNumScalingKeys = (unsigned int)intBone->pkeyPositions.size();
pcNodeAnim->mNumRotationKeys = (unsigned int)intBone->pkeyPositions.size();
pcNodeAnim->mPositionKeys = new aiVectorKey[pcNodeAnim->mNumPositionKeys];
pcNodeAnim->mScalingKeys = new aiVectorKey[pcNodeAnim->mNumPositionKeys];
pcNodeAnim->mRotationKeys = new aiQuatKey[pcNodeAnim->mNumPositionKeys];
// copy all keys
for (unsigned int qq = 0; qq < pcNodeAnim->mNumPositionKeys;++qq) {
pcNodeAnim->mPositionKeys[qq] = intBone->pkeyPositions[qq];
pcNodeAnim->mScalingKeys[qq] = intBone->pkeyScalings[qq];
pcNodeAnim->mRotationKeys[qq] = intBone->pkeyRotations[qq];
}
}
}
// store the output animation
pScene->mNumAnimations = 1;
pScene->mAnimations = new aiAnimation*[1];
pScene->mAnimations[0] = pcAnim;
}
else delete pcAnim;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
testq %rsi, %rsi
je 0x2ff389
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
movq 0xa0(%rdi), %r15
movl $0x448, %edi # imm = 0x448
callq 0x1a5230
movq %rax, %r14
xorl %ebx, %ebx
movl %ebx, (%rax)
movb $0x0, 0x4(%rax)
leaq 0x5(%rax), %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
movsd 0x28d623(%rip), %xmm0 # 0x58c598
movupd %xmm0, 0x408(%r14)
movl %ebx, 0x418(%r14)
movq %rbx, 0x420(%r14)
movl %ebx, 0x428(%r14)
movq %rbx, 0x430(%r14)
movl %ebx, 0x438(%r14)
movq %rbx, 0x440(%r14)
movq %r15, 0x28(%rsp)
movl 0x8(%r15), %r15d
testq %r15, %r15
je 0x2ff30d
movsd 0x28d5d6(%rip), %xmm0 # 0x58c598
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
xorl %eax, %eax
movq (%r12,%rax,8), %rdx
movq 0x468(%rdx), %rcx
movq 0x470(%rdx), %rdx
cmpq %rdx, %rcx
je 0x2ff01c
subq %rcx, %rdx
sarq $0x3, %rdx
imulq %rdi, %rdx
xorl %esi, %esi
movapd %xmm0, %xmm1
movsd (%rcx), %xmm0
maxsd %xmm1, %xmm0
movsd %xmm0, 0x408(%r14)
incq %rsi
addq $0x18, %rcx
cmpq %rdx, %rsi
jb 0x2feff2
incl %ebx
movl %ebx, 0x418(%r14)
incq %rax
cmpq %r15, %rax
jb 0x2fefce
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2ff034
jnp 0x2ff363
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x1a57a0
movq %rax, 0x420(%r14)
testq %r15, %r15
je 0x2ff31b
xorl %ecx, %ecx
movl $0x0, 0x4(%rsp)
movq %r12, 0x8(%rsp)
movq (%r12,%rcx,8), %r15
movq 0x468(%r15), %rax
cmpq 0x470(%r15), %rax
je 0x2ff2f7
movq %rcx, 0x18(%rsp)
movl $0x438, %edi # imm = 0x438
callq 0x1a5230
movq %rax, %r13
xorl %r12d, %r12d
movl %r12d, (%rax)
addq $0x4, %rax
movq %rax, 0x10(%rsp)
movb %r12b, 0x4(%r13)
leaq 0x5(%r13), %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
movq $0x0, 0x418(%r13)
movl %r12d, 0x420(%r13)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x404(%r13)
movupd %xmm0, 0x428(%r13)
movq 0x420(%r14), %rax
movl 0x4(%rsp), %ecx
movq %r13, (%rax,%rcx,8)
movl (%r15), %ebx
movl $0x3ff, %eax # imm = 0x3FF
cmpl %eax, %ebx
cmovael %eax, %ebx
leaq 0x4(%r15), %rsi
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x1a5110
movb %r12b, 0x38(%rsp,%rbx)
movl %ebx, (%r13)
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1a5110
movb %r12b, 0x4(%r13,%rbx)
movq 0x470(%r15), %r12
subq 0x468(%r15), %r12
sarq $0x3, %r12
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movl %r12d, 0x404(%r13)
movq 0x470(%r15), %rax
subq 0x468(%r15), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x420(%r13)
movq 0x470(%r15), %rax
subq 0x468(%r15), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x410(%r13)
movl %r12d, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rbp
movq %rbp, %rdi
callq 0x1a57a0
xorpd %xmm0, %xmm0
testl %r12d, %r12d
je 0x2ff1bd
xorl %ecx, %ecx
movupd %xmm0, (%rax,%rcx)
movl $0x0, 0x10(%rax,%rcx)
addq $0x18, %rcx
cmpq %rcx, %rbp
jne 0x2ff1a7
incl 0x4(%rsp)
movq %rax, 0x408(%r13)
movl %r12d, %eax
movq %rax, 0x10(%rsp)
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rbx
movq %rbx, %rdi
callq 0x1a57a0
testl %r12d, %r12d
je 0x2ff2d7
movq %r13, %rcx
addq $0x428, %rcx # imm = 0x428
xorl %edx, %edx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax,%rdx)
movl $0x0, 0x10(%rax,%rdx)
addq $0x18, %rdx
cmpq %rdx, %rbp
jne 0x2ff1fd
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x1a57a0
movq 0x10(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq %rax, %rdx
movss 0x25c37a(%rip), %xmm0 # 0x55b5b0
movq $0x0, (%rdx)
movupd %xmm0, 0x8(%rdx)
addq $0x18, %rdx
cmpq %rcx, %rdx
jne 0x2ff236
movq %rax, 0x418(%r13)
testl %r12d, %r12d
je 0x2ff2ed
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x8(%rsp), %r12
movq 0x468(%r15), %rdx
movq 0x408(%r13), %rsi
movl 0x10(%rdx,%rax), %edi
movl %edi, 0x10(%rsi,%rax)
movups (%rdx,%rax), %xmm0
movups %xmm0, (%rsi,%rax)
movq 0x480(%r15), %rdx
movq 0x428(%r13), %rsi
movl 0x10(%rdx,%rax), %edi
movl %edi, 0x10(%rsi,%rax)
movups (%rdx,%rax), %xmm0
movups %xmm0, (%rsi,%rax)
movq 0x498(%r15), %rdx
movq 0x418(%r13), %rsi
movq 0x10(%rdx,%rax), %rdi
movq %rdi, 0x10(%rsi,%rax)
movupd (%rdx,%rax), %xmm0
movupd %xmm0, (%rsi,%rax)
incq %rcx
movl 0x404(%r13), %edx
addq $0x18, %rax
cmpq %rdx, %rcx
jb 0x2ff264
jmp 0x2ff2f2
movq %rax, 0x428(%r13)
movq %rbx, %rdi
callq 0x1a57a0
movq %rax, 0x418(%r13)
movq 0x8(%rsp), %r12
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
cmpq %rax, %rcx
jb 0x2ff05e
jmp 0x2ff31b
xorl %edi, %edi
callq 0x1a57a0
movq %rax, 0x420(%r14)
movq 0x20(%rsp), %rbx
movq 0xb8(%rbx), %rax
movl $0x1, 0x30(%rax)
movl $0x8, %edi
callq 0x1a57a0
movq 0xb8(%rbx), %rcx
movq %rax, 0x38(%rcx)
movq 0xb8(%rbx), %rax
movq 0x38(%rax), %rax
movq %r14, (%rax)
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x240bc6
movl $0x448, %esi # imm = 0x448
movq %r14, %rdi
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a5190
leaq 0x2a3e58(%rip), %rdi # 0x5a31e8
leaq 0x2a3305(%rip), %rsi # 0x5a269c
leaq 0x2a3e60(%rip), %rcx # 0x5a31fe
movl $0x6b1, %edx # imm = 0x6B1
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/assimp/code/MDL/MDLLoader.cpp |
Assimp::MDLImporter::ParseTextureColorData(unsigned char const*, unsigned int, unsigned int*, aiTexture*) | void MDLImporter::ParseTextureColorData(const unsigned char* szData,
unsigned int iType,
unsigned int* piSkip,
aiTexture* pcNew)
{
const bool do_read = bad_texel != pcNew->pcData;
// allocate storage for the texture image
if (do_read) {
pcNew->pcData = new aiTexel[pcNew->mWidth * pcNew->mHeight];
}
// R5G6B5 format (with or without MIPs)
// ****************************************************************
if (2 == iType || 10 == iType)
{
VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*2);
// copy texture data
unsigned int i;
if (do_read)
{
for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
{
MDL::RGB565 val = ((MDL::RGB565*)szData)[i];
AI_SWAP2(val);
pcNew->pcData[i].a = 0xFF;
pcNew->pcData[i].r = (unsigned char)val.b << 3;
pcNew->pcData[i].g = (unsigned char)val.g << 2;
pcNew->pcData[i].b = (unsigned char)val.r << 3;
}
}
else i = pcNew->mWidth*pcNew->mHeight;
*piSkip = i * 2;
// apply MIP maps
if (10 == iType)
{
*piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) << 1;
VALIDATE_FILE_SIZE(szData + *piSkip);
}
}
// ARGB4 format (with or without MIPs)
// ****************************************************************
else if (3 == iType || 11 == iType)
{
VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*4);
// copy texture data
unsigned int i;
if (do_read)
{
for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
{
MDL::ARGB4 val = ((MDL::ARGB4*)szData)[i];
AI_SWAP2(val);
pcNew->pcData[i].a = (unsigned char)val.a << 4;
pcNew->pcData[i].r = (unsigned char)val.r << 4;
pcNew->pcData[i].g = (unsigned char)val.g << 4;
pcNew->pcData[i].b = (unsigned char)val.b << 4;
}
}
else i = pcNew->mWidth*pcNew->mHeight;
*piSkip = i * 2;
// apply MIP maps
if (11 == iType)
{
*piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) << 1;
VALIDATE_FILE_SIZE(szData + *piSkip);
}
}
// RGB8 format (with or without MIPs)
// ****************************************************************
else if (4 == iType || 12 == iType)
{
VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*3);
// copy texture data
unsigned int i;
if (do_read)
{
for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
{
const unsigned char* _szData = &szData[i*3];
pcNew->pcData[i].a = 0xFF;
pcNew->pcData[i].b = *_szData++;
pcNew->pcData[i].g = *_szData++;
pcNew->pcData[i].r = *_szData;
}
}
else i = pcNew->mWidth*pcNew->mHeight;
// apply MIP maps
*piSkip = i * 3;
if (12 == iType)
{
*piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) *3;
VALIDATE_FILE_SIZE(szData + *piSkip);
}
}
// ARGB8 format (with ir without MIPs)
// ****************************************************************
else if (5 == iType || 13 == iType)
{
VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight*4);
// copy texture data
unsigned int i;
if (do_read)
{
for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
{
const unsigned char* _szData = &szData[i*4];
pcNew->pcData[i].b = *_szData++;
pcNew->pcData[i].g = *_szData++;
pcNew->pcData[i].r = *_szData++;
pcNew->pcData[i].a = *_szData;
}
}
else i = pcNew->mWidth*pcNew->mHeight;
// apply MIP maps
*piSkip = i << 2;
if (13 == iType)
{
*piSkip += ((i >> 2) + (i >> 4) + (i >> 6)) << 2;
}
}
// palletized 8 bit texture. As for Quake 1
// ****************************************************************
else if (0 == iType)
{
VALIDATE_FILE_SIZE(szData + pcNew->mWidth*pcNew->mHeight);
// copy texture data
unsigned int i;
if (do_read)
{
const unsigned char* szColorMap;
SearchPalette(&szColorMap);
for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
{
const unsigned char val = szData[i];
const unsigned char* sz = &szColorMap[val*3];
pcNew->pcData[i].a = 0xFF;
pcNew->pcData[i].r = *sz++;
pcNew->pcData[i].g = *sz++;
pcNew->pcData[i].b = *sz;
}
this->FreePalette(szColorMap);
}
else i = pcNew->mWidth*pcNew->mHeight;
*piSkip = i;
// FIXME: Also support for MIP maps?
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%r8), %r13
cmpq $-0x1, %r13
je 0x300627
movl 0x4(%r12), %edi
imull (%r12), %edi
shlq $0x2, %rdi
callq 0x1a57a0
movq %rax, 0x18(%r12)
movl %ebp, %eax
orl $0x8, %eax
cmpl $0xa, %eax
jne 0x3006c9
movl (%r12), %esi
imull 0x4(%r12), %esi
addl %esi, %esi
addq %r14, %rsi
leaq 0x2a2e44(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movl $0xf9, %ecx
callq 0x2fca7a
movl 0x4(%r12), %eax
imull (%r12), %eax
cmpq $-0x1, %r13
je 0x30076d
testl %eax, %eax
je 0x30076b
xorl %eax, %eax
movzwl (%r14,%rax,2), %ecx
movq 0x18(%r12), %rdx
movb $-0x1, 0x3(%rdx,%rax,4)
movl %ecx, %edx
shrl $0x8, %edx
andb $-0x8, %dl
movq 0x18(%r12), %rsi
movb %dl, 0x2(%rsi,%rax,4)
movl %ecx, %edx
shrl $0x3, %edx
andb $-0x4, %dl
movq 0x18(%r12), %rsi
movb %dl, 0x1(%rsi,%rax,4)
shlb $0x3, %cl
movq 0x18(%r12), %rdx
movb %cl, (%rdx,%rax,4)
incq %rax
movl 0x4(%r12), %ecx
imull (%r12), %ecx
cmpq %rcx, %rax
jb 0x300676
jmp 0x30076d
cmpl $0xb, %eax
jne 0x3007ac
movl (%r12), %esi
imull 0x4(%r12), %esi
shll $0x2, %esi
addq %r14, %rsi
leaq 0x2a2da6(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movl $0x118, %ecx # imm = 0x118
callq 0x2fca7a
movl 0x4(%r12), %eax
imull (%r12), %eax
cmpq $-0x1, %r13
je 0x30084c
testl %eax, %eax
je 0x30084a
xorl %eax, %eax
movzwl (%r14,%rax,2), %ecx
movl %ecx, %edx
shlb $0x4, %dl
movq 0x18(%r12), %rsi
movb %dl, 0x3(%rsi,%rax,4)
movl %ecx, %edx
andb $-0x10, %dl
movq 0x18(%r12), %rsi
movb %dl, 0x2(%rsi,%rax,4)
movl %ecx, %edx
shrl $0x4, %edx
andb $-0x10, %dl
movq 0x18(%r12), %rsi
movb %dl, 0x1(%rsi,%rax,4)
shrl $0x8, %ecx
andb $-0x10, %cl
movq 0x18(%r12), %rdx
movb %cl, (%rdx,%rax,4)
incq %rax
movl 0x4(%r12), %ecx
imull (%r12), %ecx
cmpq %rcx, %rax
jb 0x300714
jmp 0x30084c
xorl %eax, %eax
leal (%rax,%rax), %ecx
movl %ecx, (%rbx)
cmpl $0xa, %ebp
jne 0x300a76
movl %eax, %ecx
shrl $0x2, %ecx
movl %eax, %edx
shrl $0x4, %edx
addl %eax, %edx
shrl $0x6, %eax
addl %ecx, %eax
addl %edx, %eax
addl %eax, %eax
movl %eax, (%rbx)
addq %rax, %r14
leaq 0x2a2cf3(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movq %r14, %rsi
movl $0x111, %ecx # imm = 0x111
jmp 0x30097b
cmpl $0xc, %eax
jne 0x30088b
movl (%r12), %eax
imull 0x4(%r12), %eax
leal (%rax,%rax,2), %esi
addq %r14, %rsi
leaq 0x2a2cc3(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movl $0x137, %ecx # imm = 0x137
callq 0x2fca7a
movl 0x4(%r12), %eax
imull (%r12), %eax
cmpq $-0x1, %r13
je 0x300940
testl %eax, %eax
je 0x30093e
xorl %ecx, %ecx
xorl %eax, %eax
movl %ecx, %edx
movq 0x18(%r12), %rsi
movb $-0x1, 0x3(%rsi,%rax,4)
movb (%r14,%rdx), %sil
movq 0x18(%r12), %rdi
movb %sil, (%rdi,%rax,4)
movb 0x1(%r14,%rdx), %sil
movq 0x18(%r12), %rdi
movb %sil, 0x1(%rdi,%rax,4)
movb 0x2(%r14,%rdx), %dl
movq 0x18(%r12), %rsi
movb %dl, 0x2(%rsi,%rax,4)
incq %rax
movl 0x4(%r12), %edx
imull (%r12), %edx
addq $0x3, %rcx
cmpq %rdx, %rax
jb 0x3007f9
jmp 0x300940
xorl %eax, %eax
leal (%rax,%rax), %ecx
movl %ecx, (%rbx)
cmpl $0xb, %ebp
jne 0x300a76
movl %eax, %ecx
shrl $0x2, %ecx
movl %eax, %edx
shrl $0x4, %edx
addl %eax, %edx
shrl $0x6, %eax
addl %ecx, %eax
addl %edx, %eax
addl %eax, %eax
movl %eax, (%rbx)
addq %rax, %r14
leaq 0x2a2c14(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movq %r14, %rsi
movl $0x130, %ecx # imm = 0x130
jmp 0x30097b
testl %ebp, %ebp
je 0x30098e
cmpl $0xd, %ebp
je 0x3008a1
cmpl $0x5, %ebp
jne 0x300a76
movl (%r12), %esi
imull 0x4(%r12), %esi
shll $0x2, %esi
addq %r14, %rsi
leaq 0x2a2bd7(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movl $0x156, %ecx # imm = 0x156
callq 0x2fca7a
movl 0x4(%r12), %eax
imull (%r12), %eax
cmpq $-0x1, %r13
je 0x300a4a
testl %eax, %eax
je 0x300a48
xorl %ecx, %ecx
xorl %eax, %eax
movl %ecx, %edx
andl $-0x4, %edx
movb (%r14,%rdx), %sil
movq 0x18(%r12), %rdi
movb %sil, (%rdi,%rcx)
movb 0x1(%r14,%rdx), %sil
movq 0x18(%r12), %rdi
movb %sil, 0x1(%rdi,%rcx)
movb 0x2(%r14,%rdx), %sil
movq 0x18(%r12), %rdi
movb %sil, 0x2(%rdi,%rcx)
movb 0x3(%r14,%rdx), %dl
movq 0x18(%r12), %rsi
movb %dl, 0x3(%rsi,%rcx)
incq %rax
movl 0x4(%r12), %edx
imull (%r12), %edx
addq $0x4, %rcx
cmpq %rdx, %rax
jb 0x3008e5
jmp 0x300a4a
xorl %eax, %eax
leal (%rax,%rax,2), %ecx
movl %ecx, (%rbx)
cmpl $0xc, %ebp
jne 0x300a76
movl %eax, %ecx
shrl $0x2, %ecx
movl %eax, %edx
shrl $0x4, %edx
addl %eax, %edx
shrl $0x6, %eax
addl %ecx, %eax
addl %edx, %eax
leal (%rax,%rax,2), %eax
movl %eax, (%rbx)
addq %rax, %r14
leaq 0x2a2b1f(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movq %r14, %rsi
movl $0x14f, %ecx # imm = 0x14F
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fca7a
movl 0x4(%r12), %esi
imull (%r12), %esi
addq %r14, %rsi
leaq 0x2a2aed(%rip), %rdx # 0x5a348f
movq %r15, %rdi
movl $0x173, %ecx # imm = 0x173
callq 0x2fca7a
cmpq $-0x1, %r13
je 0x300a69
movq %rsp, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x300084
movl 0x4(%r12), %eax
imull (%r12), %eax
movq (%r13), %rdi
xorl %r15d, %r15d
testl %eax, %eax
je 0x300a2a
movzbl (%r14,%r15), %eax
leaq (%rax,%rax,2), %rax
movq 0x18(%r12), %rcx
movb $-0x1, 0x3(%rcx,%r15,4)
movb (%rdi,%rax), %cl
movq 0x18(%r12), %rdx
movb %cl, 0x2(%rdx,%r15,4)
movb 0x1(%rdi,%rax), %cl
movq 0x18(%r12), %rdx
movb %cl, 0x1(%rdx,%r15,4)
movb 0x2(%rdi,%rax), %al
movq 0x18(%r12), %rcx
movb %al, (%rcx,%r15,4)
incq %r15
movl 0x4(%r12), %eax
imull (%r12), %eax
cmpq %rax, %r15
jb 0x3009dc
leaq 0x2a2dff(%rip), %rax # 0x5a3830
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x300a73
callq 0x1a5610
jmp 0x300a73
xorl %eax, %eax
cmpl $0xd, %ebp
jne 0x300a62
movl %eax, %ecx
shrl $0x2, %ecx
movl %eax, %edx
shrl $0x4, %edx
addl %eax, %edx
shrl $0x6, %eax
addl %ecx, %eax
addl %edx, %eax
shll $0x2, %eax
movl %eax, (%rbx)
jmp 0x300a76
movl 0x4(%r12), %r15d
imull (%r12), %r15d
movl %r15d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/MDL/MDLMaterialLoader.cpp |
unsigned short Assimp::StreamReader<true, false>::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), %rax
leaq 0x2(%rax), %rcx
cmpq 0x28(%rdi), %rcx
ja 0x30d7ba
movzwl (%rax), %eax
movq %rcx, 0x18(%rdi)
rolw $0x8, %ax
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 0x28a9fb(%rip), %rsi # 0x5981d2
leaq 0x28aa1b(%rip), %rdx # 0x5981f9
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3cff39(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3cff05(%rip), %rsi # 0x6dd710
movq 0x49e74e(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x30d834
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x30d83e
jmp 0x30d846
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/include/assimp/StreamReader.h |
Assimp::ObjFileImporter::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const | bool ObjFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler , bool checkSig ) const {
if(!checkSig) {
//Check File Extension
return SimpleExtensionCheck(pFile,"obj");
} else {
// Check file Header
static const char *pTokens[] = { "mtllib", "usemtl", "v ", "vt ", "vn ", "o ", "g ", "s ", "f " };
return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 9, 200, false, true );
}
} | testl %ecx, %ecx
je 0x30f1c0
pushq %rax
movl $0x1, (%rsp)
leaq 0x49fb9b(%rip), %rax # 0x7aed40
movq %rdx, %rdi
movq %rax, %rdx
movl $0x9, %ecx
movl $0xc8, %r8d
xorl %r9d, %r9d
callq 0x247ca8
popq %rcx
retq
leaq 0x295329(%rip), %rax # 0x5a44f0
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x2480ea
| /hbina[P]fatuous/thirdparty/assimp/code/Obj/ObjFileImporter.cpp |
Assimp::ObjFileParser::parseFile(Assimp::IOStreamBuffer<char>&) | void ObjFileParser::parseFile( IOStreamBuffer<char> &streamBuffer ) {
// only update every 100KB or it'll be too slow
//const unsigned int updateProgressEveryBytes = 100 * 1024;
unsigned int progressCounter = 0;
const unsigned int bytesToProcess = static_cast<unsigned int>(streamBuffer.size());
const unsigned int progressTotal = bytesToProcess;
unsigned int processed = 0;
size_t lastFilePos( 0 );
std::vector<char> buffer;
while ( streamBuffer.getNextDataLine( buffer, '\\' ) ) {
m_DataIt = buffer.begin();
m_DataItEnd = buffer.end();
// Handle progress reporting
const size_t filePos( streamBuffer.getFilePos() );
if ( lastFilePos < filePos ) {
processed = static_cast<unsigned int>(filePos);
lastFilePos = filePos;
progressCounter++;
m_progress->UpdateFileRead( processed, progressTotal );
}
// parse line
switch (*m_DataIt) {
case 'v': // Parse a vertex texture coordinate
{
++m_DataIt;
if (*m_DataIt == ' ' || *m_DataIt == '\t') {
size_t numComponents = getNumComponentsInDataDefinition();
if (numComponents == 3) {
// read in vertex definition
getVector3(m_pModel->m_Vertices);
} else if (numComponents == 4) {
// read in vertex definition (homogeneous coords)
getHomogeneousVector3(m_pModel->m_Vertices);
} else if (numComponents == 6) {
// read vertex and vertex-color
getTwoVectors3(m_pModel->m_Vertices, m_pModel->m_VertexColors);
}
} else if (*m_DataIt == 't') {
// read in texture coordinate ( 2D or 3D )
++m_DataIt;
size_t dim = getTexCoordVector(m_pModel->m_TextureCoord);
m_pModel->m_TextureCoordDim = std::max(m_pModel->m_TextureCoordDim, (unsigned int)dim);
} else if (*m_DataIt == 'n') {
// Read in normal vector definition
++m_DataIt;
getVector3( m_pModel->m_Normals );
}
}
break;
case 'p': // Parse a face, line or point statement
case 'l':
case 'f':
{
getFace(*m_DataIt == 'f' ? aiPrimitiveType_POLYGON : (*m_DataIt == 'l'
? aiPrimitiveType_LINE : aiPrimitiveType_POINT));
}
break;
case '#': // Parse a comment
{
getComment();
}
break;
case 'u': // Parse a material desc. setter
{
std::string name;
getNameNoSpace(m_DataIt, m_DataItEnd, name);
size_t nextSpace = name.find(" ");
if (nextSpace != std::string::npos)
name = name.substr(0, nextSpace);
if(name == "usemtl")
{
getMaterialDesc();
}
}
break;
case 'm': // Parse a material library or merging group ('mg')
{
std::string name;
getNameNoSpace(m_DataIt, m_DataItEnd, name);
size_t nextSpace = name.find(" ");
if (nextSpace != std::string::npos)
name = name.substr(0, nextSpace);
if (name == "mg")
getGroupNumberAndResolution();
else if(name == "mtllib")
getMaterialLib();
else
goto pf_skip_line;
}
break;
case 'g': // Parse group name
{
getGroupName();
}
break;
case 's': // Parse group number
{
getGroupNumber();
}
break;
case 'o': // Parse object name
{
getObjectName();
}
break;
default:
{
pf_skip_line:
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}
break;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movl %eax, 0x2c(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ebp, %ebp
leaq 0x2932bb(%rip), %r12 # 0x5a4a20
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
movl $0x5c, %edx
callq 0x31480c
movq 0x30(%rsp), %rdi
testb %al, %al
je 0x311b3c
movq %rdi, (%r14)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%r14)
movq 0x48(%rbx), %r13
cmpq %r13, %rbp
jae 0x3117b3
movq 0x1028(%r14), %rdi
movq (%rdi), %rax
movl %r13d, %esi
movl 0x2c(%rsp), %edx
callq *0x18(%rax)
movq (%r14), %rdi
movq %r13, %rbp
movb (%rdi), %al
movzbl %al, %ecx
leal -0x66(%rcx), %edx
cmpl $0x10, %edx
ja 0x3117d8
movslq (%r12,%rdx,4), %rcx
addq %r12, %rcx
jmpq *%rcx
xorl %esi, %esi
cmpb $0x6c, %al
sete %sil
incl %esi
jmp 0x311921
cmpl $0x23, %ecx
jne 0x311a83
movq %r14, %rdi
callq 0x312c40
jmp 0x311765
movq %r14, %rdi
callq 0x313990
jmp 0x311765
leaq 0x1(%rdi), %rax
movq %rax, (%r14)
movzbl 0x1(%rdi), %eax
cmpl $0x6d, %eax
jg 0x3119fc
cmpl $0x9, %eax
je 0x31181d
cmpl $0x20, %eax
jne 0x311765
movq %r14, %rdi
callq 0x311bf6
cmpq $0x6, %rax
je 0x311b20
cmpq $0x4, %rax
je 0x311b0b
cmpq $0x3, %rax
jne 0x311765
movq 0x10(%r14), %rsi
addq $0x68, %rsi
movq %r14, %rdi
callq 0x311dda
jmp 0x311765
movq %r14, %rdi
callq 0x313922
jmp 0x311765
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x3149a0
movl $0x1, %ecx
movq %r13, %rdi
leaq 0x24da6f(%rip), %rsi # 0x55f30c
xorl %edx, %edx
callq 0x1a55c0
cmpq $-0x1, %rax
je 0x3118e6
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x1a6240
movq %r13, %rdi
movq %r15, %rsi
callq 0x1a58d0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x3118e6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %r13, %rdi
leaq 0x293200(%rip), %rsi # 0x5a4af0
callq 0x1a60c0
testl %eax, %eax
je 0x311a43
movq %r13, %rdi
leaq 0x292bed(%rip), %rsi # 0x5a44f4
callq 0x1a60c0
testl %eax, %eax
je 0x311a50
xorl %r13d, %r13d
jmp 0x311a5b
movl $0x8, %esi
movq %r14, %rdi
callq 0x3126c8
jmp 0x311765
movq %r14, %rdi
callq 0x313706
jmp 0x311765
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdx
callq 0x3149a0
movl $0x1, %ecx
movq %r13, %rdi
leaq 0x24d999(%rip), %rsi # 0x55f30c
xorl %edx, %edx
callq 0x1a55c0
cmpq $-0x1, %rax
je 0x3119bc
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x1a6240
movq %r13, %rdi
movq %r15, %rsi
callq 0x1a58d0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x3119bc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %r13, %rdi
leaq 0x292b35(%rip), %rsi # 0x5a44fb
callq 0x1a60c0
testl %eax, %eax
jne 0x3119d7
movq %r14, %rdi
callq 0x312cae
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x311765
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x311765
cmpl $0x6e, %eax
je 0x311aef
cmpl $0x74, %eax
jne 0x311765
addq $0x2, %rdi
movq %rdi, (%r14)
movq 0x10(%r14), %rsi
movl $0x108, %eax # imm = 0x108
addq %rax, %rsi
movq %r14, %rdi
callq 0x3123fa
movq 0x10(%r14), %rcx
movl 0x120(%rcx), %edx
cmpl %eax, %edx
cmoval %edx, %eax
movl %eax, 0x120(%rcx)
jmp 0x311765
movq %r14, %rdi
callq 0x3130f4
movb $0x1, %r13b
jmp 0x311a5b
movb $0x1, %r13b
movq %r14, %rdi
callq 0x313162
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x311a77
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %r13b, %r13b
jne 0x311765
movq (%r14), %rdi
movq 0x8(%r14), %rax
leaq -0x1(%rax), %rcx
cmpq %rax, %rdi
sete %dl
cmpq %rdi, %rcx
sete %sil
orb %dl, %sil
je 0x311ace
cmpq %rax, %rdi
je 0x311aa9
incq %rdi
incl 0x18(%r14)
cmpq %rax, %rdi
je 0x311ac6
movzbl (%rdi), %ecx
cmpl $0x20, %ecx
je 0x311abb
cmpl $0x9, %ecx
jne 0x311ac6
incq %rdi
cmpq %rax, %rdi
jne 0x311aae
movq %rax, %rdi
movq %rdi, (%r14)
jmp 0x311765
movzbl (%rdi), %edx
cmpl $0xd, %edx
ja 0x311ae0
movl $0x3401, %esi # imm = 0x3401
btl %edx, %esi
jb 0x311a9d
incq %rdi
cmpq %rax, %rdi
je 0x311a9d
cmpq %rcx, %rdi
jne 0x311ace
jmp 0x311a9d
addq $0x2, %rdi
movq %rdi, (%r14)
movq 0x10(%r14), %rsi
subq $-0x80, %rsi
movq %r14, %rdi
callq 0x311dda
jmp 0x311765
movq 0x10(%r14), %rsi
addq $0x68, %rsi
movq %r14, %rdi
callq 0x311f4c
jmp 0x311765
movq 0x10(%r14), %rdx
leaq 0x68(%rdx), %rsi
addq $0x98, %rdx
movq %r14, %rdi
callq 0x312198
jmp 0x311765
testq %rdi, %rdi
je 0x311b4e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x311b8e
jmp 0x311b6b
jmp 0x311b8e
jmp 0x311b6b
jmp 0x311b6b
jmp 0x311b6b
jmp 0x311b6b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x311b91
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x311b91
jmp 0x311b8e
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x311ba8
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Obj/ObjFileParser.cpp |
Assimp::ObjFileParser::getHomogeneousVector3(std::vector<aiVector3t<float>, std::allocator<aiVector3t<float>>>&) | void ObjFileParser::getHomogeneousVector3( std::vector<aiVector3D> &point3d_array ) {
ai_real x, y, z, w;
copyNextWord(m_buffer, Buffersize);
x = (ai_real) fast_atof(m_buffer);
copyNextWord(m_buffer, Buffersize);
y = (ai_real) fast_atof(m_buffer);
copyNextWord( m_buffer, Buffersize );
z = ( ai_real ) fast_atof( m_buffer );
copyNextWord( m_buffer, Buffersize );
w = ( ai_real ) fast_atof( m_buffer );
if (w == 0)
throw DeadlyImportError("OBJ: Invalid component in homogeneous vector (Division by zero)");
point3d_array.push_back( aiVector3D( x/w, y/w, z/w ) );
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c(%rdi), %r15
movl $0x1000, %edx # imm = 0x1000
movq %r15, %rsi
callq 0x313b76
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movl %ebp, (%r12)
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x2470c9
movss (%r12), %xmm0
movaps %xmm0, 0x40(%rsp)
movl $0x1000, %edx # imm = 0x1000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x313b76
movl %ebp, (%r12)
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x2470c9
movss (%r12), %xmm0
movaps %xmm0, 0x30(%rsp)
movl $0x1000, %edx # imm = 0x1000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x313b76
movl %ebp, (%r12)
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x2470c9
movss (%r12), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0x1000, %edx # imm = 0x1000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x313b76
movl %ebp, (%r12)
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x2470c9
movss (%r12), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x31203b
jnp 0x312104
movaps 0x40(%rsp), %xmm1
unpcklps 0x30(%rsp), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movss 0xc(%rsp), %xmm2
divss %xmm0, %xmm2
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
divps %xmm0, %xmm1
movlps %xmm1, 0x10(%rsp)
movss %xmm2, 0x18(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x312080
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x8(%r14)
jmp 0x31208d
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x289640
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rcx, %rax
sete %sil
cmpq %rax, %rdx
sete %dil
orb %sil, %dil
je 0x3120e3
cmpq %rcx, %rax
je 0x3120b6
incq %rax
incl 0x18(%rbx)
cmpq %rcx, %rax
je 0x3120d3
movzbl (%rax), %edx
cmpl $0x20, %edx
je 0x3120c8
cmpl $0x9, %edx
jne 0x3120d3
incq %rax
cmpq %rcx, %rax
jne 0x3120bb
movq %rcx, %rax
movq %rax, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x3401, %esi # imm = 0x3401
movzbl (%rax), %edi
cmpl $0xd, %edi
ja 0x3120f5
btl %edi, %esi
jb 0x3120ab
incq %rax
cmpq %rcx, %rax
je 0x3120ab
cmpq %rdx, %rax
jne 0x3120e8
jmp 0x3120ab
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x292ab2(%rip), %rsi # 0x5a4bd3
leaq 0x292aea(%rip), %rdx # 0x5a4c12
leaq 0x10(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x3cb5ef(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3cb5bb(%rip), %rsi # 0x6dd710
movq 0x499e04(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x31217e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x312188
jmp 0x312190
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Obj/ObjFileParser.cpp |
Assimp::ObjFileParser::getMaterialDesc() | void ObjFileParser::getMaterialDesc() {
// Get next data for material data
m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
if (m_DataIt == m_DataItEnd) {
return;
}
char *pStart = &(*m_DataIt);
while( m_DataIt != m_DataItEnd && !IsLineEnd( *m_DataIt ) ) {
++m_DataIt;
}
// In some cases we should ignore this 'usemtl' command, this variable helps us to do so
bool skip = false;
// Get name
std::string strName(pStart, &(*m_DataIt));
strName = trim_whitespaces(strName);
if (strName.empty())
skip = true;
// If the current mesh has the same material, we simply ignore that 'usemtl' command
// There is no need to create another object or even mesh here
if ( m_pModel->m_pCurrentMaterial && m_pModel->m_pCurrentMaterial->MaterialName == aiString( strName ) ) {
skip = true;
}
if (!skip) {
// Search for material
std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find(strName);
if (it == m_pModel->m_MaterialMap.end()) {
// Not found, so we don't know anything about the material except for its name.
// This may be the case if the material library is missing. We don't want to lose all
// materials if that happens, so create a new named material instead of discarding it
// completely.
ASSIMP_LOG_ERROR("OBJ: failed to locate material " + strName + ", creating new material");
m_pModel->m_pCurrentMaterial = new ObjFile::Material();
m_pModel->m_pCurrentMaterial->MaterialName.Set(strName);
m_pModel->m_MaterialLib.push_back(strName);
m_pModel->m_MaterialMap[strName] = m_pModel->m_pCurrentMaterial;
} else {
// Found, using detected material
m_pModel->m_pCurrentMaterial = (*it).second;
}
if ( needsNewMesh( strName ) ) {
createMesh( strName );
}
m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex(strName);
}
// Skip rest of line
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x468, %rsp # imm = 0x468
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
leaq -0x1(%rax), %rcx
cmpq %rax, %rsi
sete %dl
cmpq %rsi, %rcx
sete %dil
orb %dl, %dil
jne 0x312d21
movabsq $0x100003601, %rdx # imm = 0x100003601
movzbl (%rsi), %edi
cmpq $0x20, %rdi
ja 0x312cf8
btq %rdi, %rdx
jb 0x312d14
incq %rsi
cmpq %rax, %rsi
je 0x312d21
cmpq %rcx, %rsi
jne 0x312ce9
jmp 0x312d21
incq %rsi
cmpq %rax, %rsi
je 0x312d21
cmpq %rcx, %rsi
je 0x312d21
movzbl (%rsi), %edx
cmpl $0x20, %edx
je 0x312d07
cmpl $0x9, %edx
je 0x312d07
movq %rsi, (%rbx)
cmpq %rax, %rsi
je 0x31303f
movl $0x3401, %ecx # imm = 0x3401
movq %rsi, %rdx
movzbl (%rdx), %edi
cmpl $0xd, %edi
ja 0x312d42
btl %edi, %ecx
jb 0x312d4d
incq %rdx
movq %rdx, (%rbx)
cmpq %rax, %rdx
jne 0x312d35
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsp, %r14
movq %r14, %rdi
callq 0x20ac60
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x20ac60
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x314b02
movq %rsp, %rdi
leaq 0x60(%rsp), %r14
movq %r14, %rsi
callq 0x1a58d0
movq (%r14), %rdi
leaq 0x70(%rsp), %r13
cmpq %r13, %rdi
je 0x312db8
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x312dcf
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x8(%rsp), %rbp
movq 0x10(%rbx), %r14
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x312e50
testl $0xfffffc00, %ebp # imm = 0xFFFFFC00
movl $0x3ff, %r12d # imm = 0x3FF
cmovel %ebp, %r12d
leaq 0x64(%rsp), %r13
movl %r12d, -0x4(%r13)
movq (%rsp), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x1a5110
movb $0x0, 0x64(%rsp,%r12)
cmpl %r12d, (%r15)
jne 0x312e46
testq %rbp, %rbp
sete %bpl
addq $0x4, %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1a5c20
testl %eax, %eax
sete %al
orb %bpl, %al
leaq 0x10(%rsp), %r12
leaq 0x70(%rsp), %r13
je 0x312e59
jmp 0x312fe0
leaq 0x10(%rsp), %r12
leaq 0x70(%rsp), %r13
testq %rbp, %rbp
je 0x312fe0
addq $0x148, %r14 # imm = 0x148
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3156d4
movq 0x10(%rbx), %rcx
leaq 0x150(%rcx), %rdx
cmpq %rdx, %rax
je 0x312e88
movq 0x40(%rax), %rax
movq %rax, 0x40(%rcx)
jmp 0x312fad
callq 0x241234
movq %rax, %r14
leaq 0x291de9(%rip), %rsi # 0x5a4c80
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
callq 0x23ca59
leaq 0x291df5(%rip), %rsi # 0x5a4ca0
leaq 0x40(%rsp), %rdi
callq 0x1a5ba0
movq %r13, 0x60(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x312ed8
movq %rdx, 0x60(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x70(%rsp)
jmp 0x312ee0
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x68(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x2411ba
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x312f1c
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x312f37
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x409c, %edi # imm = 0x409C
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x31454c
movq 0x10(%rbx), %rax
movq %r14, 0x40(%rax)
movq 0x8(%rsp), %r14
cmpq $0x3ff, %r14 # imm = 0x3FF
ja 0x312f83
movq 0x10(%rbx), %rax
movq 0x40(%rax), %r15
movl %r14d, (%r15)
leaq 0x4(%r15), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r15,%r14)
movq 0x10(%rbx), %rdi
addq $0x50, %rdi
movq %rsp, %rsi
callq 0x23e828
movq 0x10(%rbx), %rdi
movq 0x40(%rdi), %r14
addq $0x148, %rdi # imm = 0x148
movq %rsp, %rsi
callq 0x31475c
movq %r14, (%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3140b6
testb %al, %al
je 0x312fc7
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x313f56
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3140ee
movq 0x10(%rbx), %rcx
movq 0x128(%rcx), %rcx
movl %eax, 0x64(%rcx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rcx, %rax
sete %sil
cmpq %rax, %rdx
sete %dil
orb %sil, %dil
je 0x313051
cmpq %rcx, %rax
je 0x313009
incq %rax
incl 0x18(%rbx)
cmpq %rcx, %rax
je 0x313026
movzbl (%rax), %edx
cmpl $0x20, %edx
je 0x31301b
cmpl $0x9, %edx
jne 0x313026
incq %rax
cmpq %rcx, %rax
jne 0x31300e
movq %rcx, %rax
movq %rax, (%rbx)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x31303f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x468, %rsp # imm = 0x468
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x3401, %esi # imm = 0x3401
movzbl (%rax), %edi
cmpl $0xd, %edi
ja 0x313063
btl %edi, %esi
jb 0x312ffe
incq %rax
cmpq %rcx, %rax
je 0x312ffe
cmpq %rdx, %rax
jne 0x313056
jmp 0x312ffe
movq %rax, %rbx
movl $0x409c, %esi # imm = 0x409C
movq %r14, %rdi
jmp 0x3130ca
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x31309e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x31309e
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3130d6
movq 0x50(%rsp), %rsi
jmp 0x3130c7
jmp 0x3130d3
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x3130d6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x3130d6
jmp 0x3130d3
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3130ec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /hbina[P]fatuous/thirdparty/assimp/code/Obj/ObjFileParser.cpp |
Assimp::ObjFileParser::getNewMaterial() | void ObjFileParser::getNewMaterial() {
m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd);
if( m_DataIt == m_DataItEnd ) {
return;
}
char *pStart = &(*m_DataIt);
std::string strMat( pStart, *m_DataIt );
while( m_DataIt != m_DataItEnd && IsSpaceOrNewLine( *m_DataIt ) ) {
++m_DataIt;
}
std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( strMat );
if ( it == m_pModel->m_MaterialMap.end() ) {
// Show a warning, if material was not found
ASSIMP_LOG_WARN("OBJ: Unsupported material requested: " + strMat);
m_pModel->m_pCurrentMaterial = m_pModel->m_pDefaultMaterial;
} else {
// Set new material
if ( needsNewMesh( strMat ) ) {
createMesh( strMat );
}
m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex( strMat );
}
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
leaq -0x1(%rax), %rcx
cmpq %rax, %rsi
sete %dl
cmpq %rsi, %rcx
sete %dil
orb %dl, %dil
jne 0x3141d3
movabsq $0x100003601, %rdx # imm = 0x100003601
movzbl (%rsi), %edi
cmpq $0x20, %rdi
ja 0x3141aa
btq %rdi, %rdx
jb 0x3141c6
incq %rsi
cmpq %rax, %rsi
je 0x3141d3
cmpq %rcx, %rsi
jne 0x31419b
jmp 0x3141d3
incq %rsi
cmpq %rax, %rsi
je 0x3141d3
cmpq %rcx, %rsi
je 0x3141d3
movzbl (%rsi), %edx
cmpl $0x20, %edx
je 0x3141b9
cmpl $0x9, %edx
je 0x3141b9
movq %rsi, (%rbx)
cmpq %rax, %rsi
sete %dl
cmpq %rsi, %rcx
sete %dil
orb %dl, %dil
jne 0x314202
movzbl (%rsi), %edx
cmpl $0x20, %edx
je 0x3141f5
cmpl $0x9, %edx
jne 0x314202
incq %rsi
cmpq %rax, %rsi
je 0x314202
cmpq %rcx, %rsi
jne 0x3141e8
movq %rsi, (%rbx)
cmpq %rax, %rsi
je 0x31435b
movsbq (%rsi), %rdx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x209290
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x314256
movabsq $0x100003601, %rdx # imm = 0x100003601
movzbl (%rax), %esi
cmpq $0x20, %rsi
ja 0x314256
btq %rsi, %rdx
jae 0x314256
incq %rax
movq %rax, (%rbx)
cmpq %rcx, %rax
jne 0x31423c
movl $0x148, %edi # imm = 0x148
addq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x3156d4
movq 0x10(%rbx), %r14
leaq 0x150(%r14), %rcx
cmpq %rcx, %rax
je 0x3142ac
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3140b6
testb %al, %al
je 0x314295
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x313f56
movq 0x10(%rbx), %r14
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3140ee
movq 0x128(%r14), %rcx
movl %eax, 0x64(%rcx)
jmp 0x3142fc
callq 0x241234
movq %rax, %r14
leaq 0x290aa2(%rip), %rsi # 0x5a4d5d
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x23ca59
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x241182
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3142f0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x10(%rbx), %rax
movq 0x48(%rax), %rcx
movq %rcx, 0x40(%rax)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rcx, %rax
sete %sil
cmpq %rax, %rdx
sete %dil
orb %sil, %dil
je 0x314365
cmpq %rcx, %rax
je 0x314325
incq %rax
incl 0x18(%rbx)
cmpq %rcx, %rax
je 0x314342
movzbl (%rax), %edx
cmpl $0x20, %edx
je 0x314337
cmpl $0x9, %edx
jne 0x314342
incq %rax
cmpq %rcx, %rax
jne 0x31432a
movq %rcx, %rax
movq %rax, (%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x31435b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x3401, %esi # imm = 0x3401
movzbl (%rax), %edi
cmpl $0xd, %edi
ja 0x314377
btl %edi, %esi
jb 0x31431a
incq %rax
cmpq %rcx, %rax
je 0x31431a
cmpq %rdx, %rax
jne 0x31436a
jmp 0x31431a
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3143ab
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x3143ab
jmp 0x3143a8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3143c1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Obj/ObjFileParser.cpp |
Assimp::ObjFile::Face::~Face() | ~Face() {
// empty
} | pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x314ad5
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x314aea
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x314b00
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x1a5190
popq %rbx
retq
| /hbina[P]fatuous/thirdparty/assimp/code/Obj/ObjFileData.h |
Assimp::Ogre::Mesh::Mesh() | Mesh::Mesh()
: hasSkeletalAnimations(false)
, skeleton(NULL)
, sharedVertexData(NULL)
, subMeshes()
, animations()
, poses()
{
} | xorl %eax, %eax
movb %al, (%rdi)
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movq %rax, 0x78(%rdi)
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Ogre/OgreStructs.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.