name string | code string | asm string | file string |
|---|---|---|---|
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->... | 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 0x2f... | /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 ... | 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 0x2f1... | /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).
// Fo... | 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 %... | /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* ha... | 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... | /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,%r... | /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)
... | 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, ... | /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... | 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
mov... | /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;
... | 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 %... | /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(%ra... | /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 ... | /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)... | /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, %... | /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;
}... | 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... | /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(descriptio... | 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)
mova... | /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)
{
co... | 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(%ri... | /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);
retur... | 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... | /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... | 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, ... | /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);
}
... | 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
cm... | /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))
{
_... | 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 0x238... | /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->accumGreenBi... | 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... | /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.os... | 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
c... | /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... | 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... | /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_P... | 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(%r... | /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->... | 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)... | /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;
... | 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 %ec... | /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... | 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
... | /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 fe... | 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, 0x... | /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;
}... | 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... | /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()
... | 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,... | /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;
... | 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)... | /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*... | 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 %r... | /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
mo... | /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;
Pars... | 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
m... | /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 0x29125... | /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<a... | 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 0x29258... | /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 ignor... | 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), %rd... | /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
... | 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 $0... | /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.mShin... | 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 %... | /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.bi... | 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
m... | /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... | 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 0x29... | /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 ... | 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, %... | /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<a... | 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, %r... | /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 0x1... | /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(... | /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, %r... | /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(%... | /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 ... | /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=**/Rea... | 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, 0x6... | /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"... | 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 %... | /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();... | 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 ... | /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... | 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
mov... | /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_... | 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
a... | /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::Ma... | 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... | /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$_" << mNodeNam... | 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... | /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 (cons... | 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 $0... | /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);... | 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... | /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->getNodeT... | 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), ... | /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") || IsElem... | 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... | /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 ch... | 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,... | /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(vertexCou... | 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... | /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();
... | 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),... | /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 = ... | 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 %r... | /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 ... | 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
... | /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(%r... | /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 ... | 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... | /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_stri... | 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... | 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)... | /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();
... | 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)
mo... | /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++;
// automatic... | 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(... | /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 " + pFil... | 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), %rd... | /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 (mFil... | 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, %r... | /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 in... | 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 0x2dbf9... | /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)
... | 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), %... | /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)
, mColorHi... | 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(%r... | /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){
c... | 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 0x23ba... | /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 + "");
... | 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(... | /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 f... | 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 0x20... | /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
m... | /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) {
... | 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,... | /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)... | 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 # 0x... | /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... | 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 %e... | /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) {
... | 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 0x2e... | /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)
pop... | /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 in... | 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... | /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) {
... | 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... | /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... | 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... | /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
le... | /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->bone... | 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... | /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-... | 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 $... | /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)... | /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 ... | 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 0x2... | /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());
cons... | 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 0... | /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 = ... | 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
... | /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;... | 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
movz... | /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_Da... | 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... | /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, %r... | /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
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.