name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
ImPlotPoint ValueGetter::getValue<float, int>(void*, int)
|
static ImPlotPoint getValue(void* data, int idx) {
const auto* this_ = static_cast<ValueGetter*>(data);
double x, y;
if constexpr (std::is_void<X>::value) {
x = static_cast<double>(idx);
} else {
x = static_cast<double>((static_cast<X*>(this_->infoX.ptr))[idx]);
}
y = static_cast<double>((static_cast<Y*>(this_->infoY.ptr))[idx]);
return ImPlotPoint(x, y);
}
|
movslq %esi, %rax
movq 0x8(%rdi), %rcx
movq 0x90(%rdi), %rdx
cvtss2sd (%rcx,%rax,4), %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm1
retq
nop
|
/JoelLinn[P]py-mahi-gui/src/implot.cpp
|
ImPlotPoint ValueGetter::getValue<double, float>(void*, int)
|
static ImPlotPoint getValue(void* data, int idx) {
const auto* this_ = static_cast<ValueGetter*>(data);
double x, y;
if constexpr (std::is_void<X>::value) {
x = static_cast<double>(idx);
} else {
x = static_cast<double>((static_cast<X*>(this_->infoX.ptr))[idx]);
}
y = static_cast<double>((static_cast<Y*>(this_->infoY.ptr))[idx]);
return ImPlotPoint(x, y);
}
|
movslq %esi, %rax
movq 0x8(%rdi), %rcx
movq 0x90(%rdi), %rdx
movsd (%rcx,%rax,8), %xmm0
cvtss2sd (%rdx,%rax,4), %xmm1
retq
nop
|
/JoelLinn[P]py-mahi-gui/src/implot.cpp
|
ImPlotPoint ValueGetter::getValue<short, int>(void*, int)
|
static ImPlotPoint getValue(void* data, int idx) {
const auto* this_ = static_cast<ValueGetter*>(data);
double x, y;
if constexpr (std::is_void<X>::value) {
x = static_cast<double>(idx);
} else {
x = static_cast<double>((static_cast<X*>(this_->infoX.ptr))[idx]);
}
y = static_cast<double>((static_cast<Y*>(this_->infoY.ptr))[idx]);
return ImPlotPoint(x, y);
}
|
movslq %esi, %rax
movq 0x8(%rdi), %rcx
movq 0x90(%rdi), %rdx
movswl (%rcx,%rax,2), %ecx
cvtsi2sd %ecx, %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm1
retq
|
/JoelLinn[P]py-mahi-gui/src/implot.cpp
|
ImPlotPoint ValueGetter::getValue<short, unsigned long>(void*, int)
|
static ImPlotPoint getValue(void* data, int idx) {
const auto* this_ = static_cast<ValueGetter*>(data);
double x, y;
if constexpr (std::is_void<X>::value) {
x = static_cast<double>(idx);
} else {
x = static_cast<double>((static_cast<X*>(this_->infoX.ptr))[idx]);
}
y = static_cast<double>((static_cast<Y*>(this_->infoY.ptr))[idx]);
return ImPlotPoint(x, y);
}
|
movslq %esi, %rax
movq 0x8(%rdi), %rcx
movswl (%rcx,%rax,2), %ecx
cvtsi2sd %ecx, %xmm0
movq 0x90(%rdi), %rcx
movsd (%rcx,%rax,8), %xmm2
unpcklps 0x214a62(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x214a6a(%rip), %xmm2 # 0x37d400
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1 # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
retq
nop
|
/JoelLinn[P]py-mahi-gui/src/implot.cpp
|
void pybind11::cpp_function::initialize<ImVec2 (*&)(double, double, int), ImVec2, double, double, int, pybind11::name, pybind11::scope, pybind11::sibling, pybind11::arg, pybind11::arg, pybind11::arg_v, char [154]>(ImVec2 (*&)(double, double, int), ImVec2 (*)(double, double, int), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg_v const&, char const (&) [154])
|
void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x114708
movq %rax, %r14
movq (%rbp), %rax
movq %rax, 0x38(%r14)
leaq 0x69(%rip), %rax # 0x16b846
movq %rax, 0x30(%r14)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x50(%rsp), %r9
pushq %r14
pushq 0x60(%rsp)
callq 0x16b3d6
addq $0x10, %rsp
leaq 0x216af5(%rip), %rdx # 0x382304
leaq 0x2fb292(%rip), %rcx # 0x466aa8
movl $0x3, %r8d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11473e
orb $0x4, 0x59(%r14)
leaq 0x2fb295(%rip), %rax # 0x466ac8
movq %rax, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h
|
void pybind11::cpp_function::initialize<bool (*&)(), bool, pybind11::name, pybind11::scope, pybind11::sibling, char [68]>(bool (*&)(), bool (*)(), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, char const (&) [68])
|
void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x114708
movq %rax, %rbp
movq (%r12), %rax
movq %rax, 0x38(%rbp)
leaq 0x5d(%rip), %rax # 0x16bd0a
movq %rax, 0x30(%rbp)
movq (%r15), %rax
movq %rax, (%rbp)
movq (%r14), %rax
movq %rax, 0x70(%rbp)
movq (%rbx), %rax
movq %rax, 0x78(%rbp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rbp)
leaq 0x216692(%rip), %rdx # 0x382368
leaq 0x21669b(%rip), %rcx # 0x382378
movq %r13, %rdi
movq %rbp, %rsi
xorl %r8d, %r8d
callq 0x11473e
orb $0x4, 0x59(%rbp)
movq 0x3015da(%rip), %rax # 0x46d2d0
movq %rax, 0x40(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h
|
void pybind11::cpp_function::initialize<ImPlotLimits (*&)(int), ImPlotLimits, int, pybind11::name, pybind11::scope, pybind11::sibling, pybind11::arg_v, char [85]>(ImPlotLimits (*&)(int), ImPlotLimits (*)(int), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, pybind11::arg_v const&, char const (&) [85])
|
void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbp
movq %rdi, %r14
callq 0x114708
movq %rax, %rbx
movq (%rbp), %rax
movq %rax, 0x38(%rbx)
leaq 0x6d(%rip), %rax # 0x16c38c
movq %rax, 0x30(%rbx)
movq (%r13), %rax
movq %rax, (%rbx)
movq (%r12), %rax
movq %rax, 0x70(%rbx)
movq (%r15), %rax
movq %rax, 0x78(%rbx)
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x138742
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x2160ba(%rip), %rdx # 0x382410
leaq 0x2fa82b(%rip), %rcx # 0x466b88
movl $0x1, %r8d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11473e
orb $0x4, 0x59(%rbx)
leaq 0x2fa7ef(%rip), %rax # 0x466b68
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h
|
bool pybind11::detail::argument_loader<char const*, Double&, Double&, bool, ImVec4 const&, float>::load_impl_sequence<0ul, 1ul, 2ul, 3ul, 4ul, 5ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>)
|
bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
if (!r)
return false;
#endif
return true;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0x16cdf4
movq %rdi, %rbx
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
cmpq 0x2fdc84(%rip), %rsi # 0x46a9a8
je 0x16cd47
leaq 0x58(%rbx), %rdi
andl $0x1, %edx
callq 0x1123c2
testb %al, %al
je 0x16cdf4
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq (%rcx), %rdx
jmp 0x16cd54
testb $0x1, %dl
je 0x16cdf4
movb $0x1, 0x78(%rbx)
leaq 0x40(%rbx), %rdi
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
callq 0x11bd98
testb %al, %al
je 0x16cdf4
leaq 0x28(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x10(%rax), %rsi
movl (%rcx), %edx
andl $0x4, %edx
shrl $0x2, %edx
callq 0x11bd98
testb %al, %al
je 0x16cdf4
leaq 0x20(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rsi
movl (%rcx), %edx
andl $0x8, %edx
shrl $0x3, %edx
callq 0x112e3c
testb %al, %al
je 0x16cdf4
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x20(%rax), %rsi
movl (%rcx), %edx
andl $0x10, %edx
shrl $0x4, %edx
callq 0x11bd98
testb %al, %al
je 0x16cdf4
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x28(%rax), %rsi
movl (%rcx), %edx
andl $0x20, %edx
shrl $0x5, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x131912
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/cast.h
|
void pybind11::cpp_function::initialize<bool (*&)(char const*), bool, char const*, pybind11::name, pybind11::scope, pybind11::sibling, pybind11::arg, char [46]>(bool (*&)(char const*), bool (*)(char const*), pybind11::name const&, pybind11::scope const&, pybind11::sibling const&, pybind11::arg const&, char const (&) [46])
|
void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbp
movq %rdi, %r14
callq 0x114708
movq %rax, %rbx
movq (%rbp), %rax
movq %rax, 0x38(%rbx)
leaq 0x6d(%rip), %rax # 0x16fff6
movq %rax, 0x30(%rbx)
movq (%r13), %rax
movq %rax, (%rbx)
movq (%r12), %rax
movq %rax, 0x70(%rbx)
movq (%r15), %rax
movq %rax, 0x78(%rbx)
movq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x11e9c2
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x2128c8(%rip), %rdx # 0x382888
leaq 0x2128d1(%rip), %rcx # 0x382898
movl $0x1, %r8d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11473e
orb $0x4, 0x59(%rbx)
movq 0x2f9ced(%rip), %rax # 0x469cd0
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h
|
void pybind11::cpp_function::initialize<pybind11::class_<mahi::gui::Application::Profile>& pybind11::class_<mahi::gui::Application::Profile>::def_readwrite<mahi::gui::Application::Profile, mahi::util::Time>(char const*, mahi::util::Time mahi::gui::Application::Profile::*)::'lambda'(mahi::gui::Application::Profile&, mahi::util::Time const&), void, mahi::gui::Application::Profile&, mahi::util::Time const&, pybind11::is_method>(mahi::gui::Application::Profile&&, mahi::util::Time (*)(), pybind11::is_method const&)
|
void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
auto rec = make_function_record();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x114708
movq (%r14), %rcx
movq %rcx, 0x38(%rax)
leaq 0x33(%rip), %rcx # 0x177e82
movq %rcx, 0x30(%rax)
orb $0x10, 0x59(%rax)
movq (%rbx), %rcx
movq %rcx, 0x70(%rax)
leaq 0x20b16f(%rip), %rdx # 0x382fd4
leaq 0x2ef394(%rip), %rcx # 0x467200
movl $0x2, %r8d
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x11473e
|
/JoelLinn[P]py-mahi-gui/thirdparty/pybind11/include/pybind11/pybind11.h
|
ExampleAppConsole::ClearLog()
|
void ClearLog()
{
for (int i = 0; i < Items.Size; i++)
free(Items[i]);
Items.clear();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x100(%rdi)
jle 0x1929e2
xorl %r14d, %r14d
movq 0x108(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xe76a0
incq %r14
movslq 0x100(%rbx), %rax
cmpq %rax, %r14
jl 0x1929c3
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x192a04
xorl %r14d, %r14d
movq %r14, 0x100(%rbx)
callq 0xe0fe0
movq %r14, 0x108(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_demo.cpp
|
ExampleAppLog::Clear()
|
void Clear()
{
Buf.clear();
LineOffsets.clear();
LineOffsets.push_back(0);
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x193941
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0xe0fe0
movq %r14, 0x8(%rbx)
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0x193963
xorl %r14d, %r14d
movq %r14, 0x128(%rbx)
callq 0xe0fe0
movq %r14, 0x130(%rbx)
movl 0x128(%rbx), %ecx
leal 0x1(%rcx), %ebp
testl %ecx, %ecx
je 0x19397d
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
addl %ecx, %eax
jmp 0x193982
movl $0x8, %eax
cmpl %ebp, %eax
cmovgl %eax, %ebp
movslq %ebp, %rdi
shlq $0x2, %rdi
callq 0xe9510
movq %rax, %r14
movq 0x130(%rbx), %rsi
testq %rsi, %rsi
je 0x1939c1
movslq 0x128(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0xe51a0
movq 0x130(%rbx), %rdi
callq 0xe0fe0
movq %r14, 0x130(%rbx)
movl %ebp, 0x12c(%rbx)
movslq 0x128(%rbx), %rax
movl $0x0, (%r14,%rax,4)
incl 0x128(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_demo.cpp
|
ImDrawListSplitter::ClearFreeMemory()
|
void ImDrawListSplitter::ClearFreeMemory()
{
for (int i = 0; i < _Channels.Size; i++)
{
if (i == _Current)
memset(&_Channels[i], 0, sizeof(_Channels[i])); // Current channel is a copy of CmdBuffer/IdxBuffer, don't destruct again
_Channels[i]._CmdBuffer.clear();
_Channels[i]._IdxBuffer.clear();
}
_Current = 0;
_Count = 1;
_Channels.clear();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x194d1f
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movl (%rbx), %ecx
cmpq %rcx, %r12
jne 0x194cbc
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%r15)
movups %xmm0, (%rax,%r15)
movl 0x8(%rbx), %eax
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x194d4f
movq 0x10(%rbx), %r13
movq 0x8(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x194ceb
movq %r14, (%r13,%r15)
callq 0xe0fe0
movq %r14, 0x8(%r13,%r15)
movl 0x8(%rbx), %eax
movslq %eax, %rcx
cmpq %r12, %rcx
jle 0x194d4f
movq 0x10(%rbx), %r13
movq 0x18(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x194d13
movq %r14, 0x10(%r13,%r15)
callq 0xe0fe0
movq %r14, 0x18(%r13,%r15)
movl 0x8(%rbx), %eax
movslq %eax, %rcx
incq %r12
addq $0x20, %r15
cmpq %rcx, %r12
jl 0x194ca0
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x194d45
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
callq 0xe0fe0
movq %r14, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1f6ca5(%rip), %rdi # 0x38b9fb
leaq 0x1f6cb1(%rip), %rsi # 0x38ba0e
leaq 0x203a6f(%rip), %rcx # 0x3987d3
movl $0x688, %edx # imm = 0x688
callq 0xe3fd0
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_draw.cpp
|
ImDrawList::_OnChangedClipRect()
|
void ImDrawList::_OnChangedClipRect()
{
// If current command is used with different settings we need to add a new command
ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
if (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &_CmdHeader.ClipRect, sizeof(ImVec4)) != 0)
{
AddDrawCmd();
return;
}
IM_ASSERT(curr_cmd->UserCallback == NULL);
// Try to merge with previous command if it matches, else use current command
ImDrawCmd* prev_cmd = curr_cmd - 1;
if (curr_cmd->ElemCount == 0 && CmdBuffer.Size > 1 && ImDrawCmd_HeaderCompare(&_CmdHeader, prev_cmd) == 0 && prev_cmd->UserCallback == NULL)
{
CmdBuffer.pop_back();
return;
}
curr_cmd->ClipRect = _CmdHeader.ClipRect;
}
|
movq 0x8(%rdi), %rdx
movslq (%rdi), %rax
imulq $0x38, %rax, %r8
leaq (%rdx,%r8), %rcx
addq $-0x38, %rcx
movl 0x20(%rcx), %esi
testl %esi, %esi
je 0x19517a
movdqu (%rcx), %xmm0
movdqu 0x88(%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r9d
cmpl $0xffff, %r9d # imm = 0xFFFF
jne 0xe7500
addq %r8, %rdx
cmpq $0x0, -0x10(%rdx)
jne 0x1951d6
cmpl $0x2, %eax
jl 0x1951c6
testl %esi, %esi
jne 0x1951c6
movdqu 0x88(%rdi), %xmm0
movdqu 0x94(%rdi), %xmm1
movdqu -0x70(%rdx), %xmm2
pcmpeqb %xmm0, %xmm2
movdqu -0x64(%rdx), %xmm0
pcmpeqb %xmm1, %xmm0
pand %xmm2, %xmm0
pmovmskb %xmm0, %esi
cmpl $0xffff, %esi # imm = 0xFFFF
jne 0x1951c6
cmpq $0x0, -0x48(%rdx)
je 0x1951d1
movups 0x88(%rdi), %xmm0
movups %xmm0, (%rcx)
retq
decl %eax
movl %eax, (%rdi)
retq
pushq %rax
leaq 0x201b38(%rip), %rdi # 0x396d16
leaq 0x201a91(%rip), %rsi # 0x396c76
leaq 0x201b80(%rip), %rcx # 0x396d6c
movl $0x1ef, %edx # imm = 0x1EF
callq 0xe3fd0
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_draw.cpp
|
ImDrawList::PrimReserve(int, int)
|
void ImDrawList::PrimReserve(int idx_count, int vtx_count)
{
// Large mesh support (when enabled)
IM_ASSERT_PARANOID(idx_count >= 0 && vtx_count >= 0);
if (sizeof(ImDrawIdx) == 2 && (_VtxCurrentIdx + vtx_count >= (1 << 16)) && (Flags & ImDrawListFlags_AllowVtxOffset))
{
// FIXME: In theory we should be testing that vtx_count <64k here.
// In practice, RenderText() relies on reserving ahead for a worst case scenario so it is currently useful for us
// to not make that check until we rework the text functions to handle clipping and large horizontal lines better.
_CmdHeader.VtxOffset = VtxBuffer.Size;
_OnChangedVtxOffset();
}
ImDrawCmd* draw_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
draw_cmd->ElemCount += idx_count;
int vtx_buffer_old_size = VtxBuffer.Size;
VtxBuffer.resize(vtx_buffer_old_size + vtx_count);
_VtxWritePtr = VtxBuffer.Data + vtx_buffer_old_size;
int idx_buffer_old_size = IdxBuffer.Size;
IdxBuffer.resize(idx_buffer_old_size + idx_count);
_IdxWritePtr = IdxBuffer.Data + idx_buffer_old_size;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
imulq $0x38, %rcx, %rcx
addl %esi, -0x18(%rax,%rcx)
movslq 0x20(%rdi), %r12
addl %r12d, %r14d
movl 0x24(%rdi), %eax
cmpl %r14d, %eax
jge 0x1955b9
testl %eax, %eax
je 0x1955bf
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addl %eax, %r13d
jmp 0x1955c5
movq 0x28(%rbx), %r15
jmp 0x19560d
movl $0x8, %r13d
cmpl %r14d, %r13d
cmovlel %r14d, %r13d
movslq %r13d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
callq 0xe9510
movq %rax, %r15
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x195605
movslq 0x20(%rbx), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r15, %rdi
callq 0xe51a0
movq 0x28(%rbx), %rdi
callq 0xe0fe0
movq %r15, 0x28(%rbx)
movl %r13d, 0x24(%rbx)
movl %r14d, 0x20(%rbx)
leaq (%r12,%r12,4), %rax
leaq (%r15,%rax,4), %rax
movq %rax, 0x48(%rbx)
movslq 0x10(%rbx), %r15
addl %r15d, %ebp
movl 0x14(%rbx), %eax
cmpl %ebp, %eax
jge 0x195641
testl %eax, %eax
je 0x195647
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0x19564d
movq 0x18(%rbx), %r14
jmp 0x19568d
movl $0x8, %r12d
cmpl %ebp, %r12d
cmovlel %ebp, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
callq 0xe9510
movq %rax, %r14
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x195685
movslq 0x10(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0xe51a0
movq 0x18(%rbx), %rdi
callq 0xe0fe0
movq %r14, 0x18(%rbx)
movl %r12d, 0x14(%rbx)
movl %ebp, 0x10(%rbx)
leaq (%r14,%r15,4), %rax
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_draw.cpp
|
ImDrawList::PathArcTo(ImVec2 const&, float, float, float, int)
|
void ImDrawList::PathArcTo(const ImVec2& center, float radius, float a_min, float a_max, int num_segments)
{
if (radius == 0.0f)
{
_Path.push_back(center);
return;
}
// Note that we are adding a point at both a_min and a_max.
// If you are trying to draw a full closed circle you don't want the overlapping points!
_Path.reserve(_Path.Size + (num_segments + 1));
for (int i = 0; i <= num_segments; i++)
{
const float a = a_min + ((float)i / (float)num_segments) * (a_max - a_min);
_Path.push_back(ImVec2(center.x + ImCos(a) * radius, center.y + ImSin(a) * radius));
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm0
movl 0x78(%rdi), %eax
jne 0x19676d
jp 0x19676d
cmpl 0x7c(%rbx), %eax
jne 0x19691d
leal 0x1(%rax), %ebp
testl %eax, %eax
je 0x196926
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x19692b
movl %edx, %r15d
leal (%r15,%rax), %ebp
incl %ebp
cmpl %ebp, 0x7c(%rbx)
movss %xmm1, 0x8(%rsp)
jge 0x1967de
movaps %xmm0, 0x10(%rsp)
movss %xmm2, 0x4(%rsp)
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0xe9510
movq %rax, %r12
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x1967c3
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r12, %rdi
callq 0xe51a0
movq 0x80(%rbx), %rdi
callq 0xe0fe0
movq %r12, 0x80(%rbx)
movl %ebp, 0x7c(%rbx)
movss 0x4(%rsp), %xmm2
movss 0x8(%rsp), %xmm1
movaps 0x10(%rsp), %xmm0
testl %r15d, %r15d
js 0x196980
xorps %xmm3, %xmm3
cvtsi2ss %r15d, %xmm3
movss %xmm3, 0xc(%rsp)
subss %xmm1, %xmm2
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
incl %r15d
xorl %ebp, %ebp
movss %xmm2, 0x4(%rsp)
movaps %xmm0, 0x10(%rsp)
xorps %xmm3, %xmm3
cvtsi2ss %ebp, %xmm3
divss 0xc(%rsp), %xmm3
mulss %xmm2, %xmm3
addss %xmm1, %xmm3
movss %xmm3, 0x20(%rsp)
movss (%r14), %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm3, %xmm0
callq 0xe4710
movaps %xmm0, 0x40(%rsp)
movss 0x4(%r14), %xmm0
movaps %xmm0, 0x30(%rsp)
movss 0x20(%rsp), %xmm0
callq 0xe5310
movl 0x78(%rbx), %r13d
cmpl 0x7c(%rbx), %r13d
jne 0x196879
testl %r13d, %r13d
movaps %xmm0, 0x20(%rsp)
je 0x196882
movl %r13d, %eax
shrl $0x1f, %eax
addl %r13d, %eax
sarl %eax
addl %r13d, %eax
jmp 0x196887
movq 0x80(%rbx), %r12
jmp 0x1968dc
movl $0x8, %eax
incl %r13d
cmpl %r13d, %eax
cmovgl %eax, %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0xe9510
movq %rax, %r12
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x1968c8
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r12, %rdi
callq 0xe51a0
movq 0x80(%rbx), %rdi
callq 0xe0fe0
movq %r12, 0x80(%rbx)
movl %r13d, 0x7c(%rbx)
movl 0x78(%rbx), %r13d
movaps 0x20(%rsp), %xmm0
movaps 0x40(%rsp), %xmm2
unpcklps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps 0x10(%rsp), %xmm0
mulps %xmm0, %xmm2
movaps 0x50(%rsp), %xmm1
unpcklps 0x30(%rsp), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
addps %xmm2, %xmm1
movslq %r13d, %rax
movlps %xmm1, (%r12,%rax,8)
incl 0x78(%rbx)
incl %ebp
cmpl %ebp, %r15d
movss 0x4(%rsp), %xmm2
movss 0x8(%rsp), %xmm1
jne 0x19680d
jmp 0x196980
movq 0x80(%rbx), %r15
jmp 0x196974
movl $0x8, %ecx
cmpl %ebp, %ecx
cmovgl %ecx, %ebp
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0xe9510
movq %rax, %r15
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x196967
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0xe51a0
movq 0x80(%rbx), %rdi
callq 0xe0fe0
movq %r15, 0x80(%rbx)
movl %ebp, 0x7c(%rbx)
movl 0x78(%rbx), %eax
cltq
movq (%r14), %rcx
movq %rcx, (%r15,%rax,8)
incl 0x78(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_draw.cpp
|
ImDrawList::AddQuad(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float)
|
void ImDrawList::AddQuad(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
PathLineTo(p1);
PathLineTo(p2);
PathLineTo(p3);
PathLineTo(p4);
PathStroke(col, true, thickness);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm0, 0x4(%rsp)
cmpl $0x1000000, %r9d # imm = 0x1000000
jb 0x1979a3
movl %r9d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, 0x10(%rsp)
movl 0x78(%rdi), %eax
cmpl 0x7c(%rdi), %eax
jne 0x19776f
movq %r15, 0x8(%rsp)
leal 0x1(%rax), %r15d
testl %eax, %eax
je 0x197778
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x19777d
movq 0x80(%rbx), %r14
jmp 0x1977ce
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
movslq %r15d, %rdi
shlq $0x3, %rdi
callq 0xe9510
movq %rax, %r14
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x1977bb
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0xe51a0
movq 0x80(%rbx), %rdi
callq 0xe0fe0
movq %r14, 0x80(%rbx)
movl %r15d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
movq 0x8(%rsp), %r15
cltq
movq (%r13), %rcx
movq %rcx, (%r14,%rax,8)
movl 0x78(%rbx), %r13d
leal 0x1(%r13), %eax
movl %eax, 0x78(%rbx)
cmpl 0x7c(%rbx), %eax
jne 0x1977fd
addl $0x2, %r13d
testl %eax, %eax
je 0x197806
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x19780b
movq 0x80(%rbx), %r14
jmp 0x197857
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0xe9510
movq %rax, %r14
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x197849
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0xe51a0
movq 0x80(%rbx), %rdi
callq 0xe0fe0
movq %r14, 0x80(%rbx)
movl %r13d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
cltq
movq (%r12), %rcx
movq %rcx, (%r14,%rax,8)
movl 0x78(%rbx), %r12d
leal 0x1(%r12), %eax
movl %eax, 0x78(%rbx)
cmpl 0x7c(%rbx), %eax
jne 0x197887
addl $0x2, %r12d
testl %eax, %eax
je 0x197890
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x197895
movq 0x80(%rbx), %r14
jmp 0x1978e1
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0xe9510
movq %rax, %r14
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x1978d3
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0xe51a0
movq 0x80(%rbx), %rdi
callq 0xe0fe0
movq %r14, 0x80(%rbx)
movl %r12d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
cltq
movq (%r15), %rcx
movq %rcx, (%r14,%rax,8)
movl 0x78(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x78(%rbx)
cmpl 0x7c(%rbx), %eax
jne 0x19790f
addl $0x2, %r15d
testl %eax, %eax
je 0x197918
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x19791d
movq 0x80(%rbx), %r14
jmp 0x197969
movl $0x8, %ecx
cmpl %r15d, %ecx
cmovgl %ecx, %r15d
movslq %r15d, %rdi
shlq $0x3, %rdi
callq 0xe9510
movq %rax, %r14
movq 0x80(%rbx), %rsi
testq %rsi, %rsi
je 0x19795b
movslq 0x78(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0xe51a0
movq 0x80(%rbx), %rdi
callq 0xe0fe0
movq %r14, 0x80(%rbx)
movl %r15d, 0x7c(%rbx)
movl 0x78(%rbx), %eax
cltq
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%r14,%rax,8)
movl 0x78(%rbx), %edx
incl %edx
movl %edx, 0x78(%rbx)
movq 0x80(%rbx), %rsi
movq %rbx, %rdi
movl %ebp, %ecx
movl $0x1, %r8d
movss 0x4(%rsp), %xmm0
callq 0xe52a0
movl $0x0, 0x78(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_draw.cpp
|
ImDrawList::AddCircle(ImVec2 const&, float, unsigned int, int, float)
|
void ImDrawList::AddCircle(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness)
{
if ((col & IM_COL32_A_MASK) == 0 || radius <= 0.0f)
return;
// Obtain segment count
if (num_segments <= 0)
{
// Automatic segment count
const int radius_idx = (int)radius - 1;
if (radius_idx < IM_ARRAYSIZE(_Data->CircleSegmentCounts))
num_segments = _Data->CircleSegmentCounts[radius_idx]; // Use cached value
else
num_segments = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(radius, _Data->CircleSegmentMaxError);
}
else
{
// Explicit segment count (still clamp to avoid drawing insanely tessellated shapes)
num_segments = ImClamp(num_segments, 3, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX);
}
// Because we are filling a closed shape we remove 1 from the count of segments/points
const float a_max = (IM_PI * 2.0f) * ((float)num_segments - 1.0f) / (float)num_segments;
if (num_segments == 12)
PathArcToFast(center, radius - 0.5f, 0, 12 - 1);
else
PathArcTo(center, radius - 0.5f, 0.0f, a_max, num_segments - 1);
PathStroke(col, true, thickness);
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movaps %xmm0, %xmm3
cmpl $0x1000000, %edx # imm = 0x1000000
setb %al
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
setae %dl
orb %al, %dl
jne 0x198171
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
movss %xmm1, 0xc(%rsp)
jle 0x198091
movl $0x200, %eax # imm = 0x200
cmpl %eax, %ecx
cmovbl %ecx, %eax
movl $0x3, %edx
cmpl $0x3, %ecx
jae 0x1980ea
jmp 0x198110
cvttss2si %xmm3, %eax
cmpl $0x40, %eax
jg 0x1980aa
cltq
movq 0x38(%rbx), %rcx
movzbl 0x8f(%rax,%rcx), %eax
jmp 0x1980ea
movq 0x38(%rbx), %rax
movaps %xmm3, %xmm0
subss 0x18(%rax), %xmm0
divss %xmm3, %xmm0
movss %xmm3, 0x8(%rsp)
callq 0xe6860
movss 0x8(%rsp), %xmm3
movss 0x1f8b71(%rip), %xmm1 # 0x390c44
divss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
movl $0x200, %eax # imm = 0x200
cmpl %eax, %ecx
cmovbl %ecx, %eax
cmpl $0xc, %ecx
jl 0x1980f1
movl %eax, %edx
cmpl $0xc, %eax
jne 0x198110
addss 0x1eb097(%rip), %xmm3 # 0x383190
movq %rbx, %rdi
movq %r14, %rsi
movaps %xmm3, %xmm0
xorl %edx, %edx
movl $0xb, %ecx
callq 0xe9560
jmp 0x19814a
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
movss 0x1daee1(%rip), %xmm2 # 0x373000
addss %xmm0, %xmm2
mulss 0x1f8b19(%rip), %xmm2 # 0x390c44
divss %xmm0, %xmm2
addss 0x1eb059(%rip), %xmm3 # 0x383190
decl %edx
xorps %xmm1, %xmm1
movq %rbx, %rdi
movq %r14, %rsi
movaps %xmm3, %xmm0
callq 0xe7230
movq 0x80(%rbx), %rsi
movl 0x78(%rbx), %edx
movq %rbx, %rdi
movl %ebp, %ecx
movl $0x1, %r8d
movss 0xc(%rsp), %xmm0
callq 0xe52a0
movl $0x0, 0x78(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_draw.cpp
|
bool ImGui::DragBehaviorT<float, float, float>(int, float*, float, float, float, char const*, int)
|
bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_decimal = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataType_Double);
const bool is_clamped = (v_min < v_max);
const bool is_logarithmic = (flags & ImGuiSliderFlags_Logarithmic) && is_decimal;
// Default tweak speed
if (v_speed == 0.0f && is_clamped && (v_max - v_min < FLT_MAX))
v_speed = (float)((v_max - v_min) * g.DragSpeedDefaultRatio);
// Inputs accumulates into g.DragCurrentAccum, which is flushed into the current value as soon as it makes a difference with our precision settings
float adjust_delta = 0.0f;
if (g.ActiveIdSource == ImGuiInputSource_Mouse && IsMousePosValid() && g.IO.MouseDragMaxDistanceSqr[0] > 1.0f * 1.0f)
{
adjust_delta = g.IO.MouseDelta[axis];
if (g.IO.KeyAlt)
adjust_delta *= 1.0f / 100.0f;
if (g.IO.KeyShift)
adjust_delta *= 10.0f;
}
else if (g.ActiveIdSource == ImGuiInputSource_Nav)
{
int decimal_precision = is_decimal ? ImParseFormatPrecision(format, 3) : 0;
adjust_delta = GetNavInputAmount2d(ImGuiNavDirSourceFlags_Keyboard | ImGuiNavDirSourceFlags_PadDPad, ImGuiInputReadMode_RepeatFast, 1.0f / 10.0f, 10.0f)[axis];
v_speed = ImMax(v_speed, GetMinimumStepAtDecimalPrecision(decimal_precision));
}
adjust_delta *= v_speed;
// For vertical drag we currently assume that Up=higher value (like we do with vertical sliders). This may become a parameter.
if (axis == ImGuiAxis_Y)
adjust_delta = -adjust_delta;
// For logarithmic use our range is effectively 0..1 so scale the delta into that range
if (is_logarithmic && (v_max - v_min < FLT_MAX) && ((v_max - v_min) > 0.000001f)) // Epsilon to avoid /0
adjust_delta /= (float)(v_max - v_min);
// Clear current value on activation
// Avoid altering values and clamping when we are _already_ past the limits and heading in the same direction, so e.g. if range is 0..255, current value is 300 and we are pushing to the right side, keep the 300.
bool is_just_activated = g.ActiveIdIsJustActivated;
bool is_already_past_limits_and_pushing_outward = is_clamped && ((*v >= v_max && adjust_delta > 0.0f) || (*v <= v_min && adjust_delta < 0.0f));
if (is_just_activated || is_already_past_limits_and_pushing_outward)
{
g.DragCurrentAccum = 0.0f;
g.DragCurrentAccumDirty = false;
}
else if (adjust_delta != 0.0f)
{
g.DragCurrentAccum += adjust_delta;
g.DragCurrentAccumDirty = true;
}
if (!g.DragCurrentAccumDirty)
return false;
TYPE v_cur = *v;
FLOATTYPE v_old_ref_for_accum_remainder = (FLOATTYPE)0.0f;
float logarithmic_zero_epsilon = 0.0f; // Only valid when is_logarithmic is true
const float zero_deadzone_halfsize = 0.0f; // Drag widgets have no deadzone (as it doesn't make sense)
if (is_logarithmic)
{
// When using logarithmic sliders, we need to clamp to avoid hitting zero, but our choice of clamp value greatly affects slider precision. We attempt to use the specified precision to estimate a good lower bound.
const int decimal_precision = is_decimal ? ImParseFormatPrecision(format, 3) : 1;
logarithmic_zero_epsilon = ImPow(0.1f, (float)decimal_precision);
// Convert to parametric space, apply delta, convert back
float v_old_parametric = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_cur, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);
float v_new_parametric = v_old_parametric + g.DragCurrentAccum;
v_cur = ScaleValueFromRatioT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_new_parametric, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);
v_old_ref_for_accum_remainder = v_old_parametric;
}
else
{
v_cur += (SIGNEDTYPE)g.DragCurrentAccum;
}
// Round to user desired precision based on format string
if (!(flags & ImGuiSliderFlags_NoRoundToFormat))
v_cur = RoundScalarWithFormatT<TYPE, SIGNEDTYPE>(format, data_type, v_cur);
// Preserve remainder after rounding has been applied. This also allow slow tweaking of values.
g.DragCurrentAccumDirty = false;
if (is_logarithmic)
{
// Convert to parametric space, apply delta, convert back
float v_new_parametric = ScaleRatioFromValueT<TYPE, SIGNEDTYPE, FLOATTYPE>(data_type, v_cur, v_min, v_max, is_logarithmic, logarithmic_zero_epsilon, zero_deadzone_halfsize);
g.DragCurrentAccum -= (float)(v_new_parametric - v_old_ref_for_accum_remainder);
}
else
{
g.DragCurrentAccum -= (float)((SIGNEDTYPE)v_cur - (SIGNEDTYPE)*v);
}
// Lose zero sign for float/double
if (v_cur == (TYPE)-0)
v_cur = (TYPE)0;
// Clamp values (+ handle overflow/wrap-around for integer types)
if (*v != v_cur && is_clamped)
{
if (v_cur < v_min || (v_cur > *v && adjust_delta < 0.0f && !is_decimal))
v_cur = v_min;
if (v_cur > v_max || (v_cur < *v && adjust_delta > 0.0f && !is_decimal))
v_cur = v_max;
}
// Apply result
if (*v == v_cur)
return false;
*v = v_cur;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, 0x40(%rsp)
movaps %xmm0, %xmm4
movq %rsi, %r12
movq 0x2a7fdf(%rip), %rax # 0x46e2b8
movq (%rax), %r14
movl %ecx, %r13d
andl $0x100000, %r13d # imm = 0x100000
movl %edi, 0x8(%rsp)
movl %edi, %eax
andl $-0x2, %eax
movl %eax, 0xc(%rsp)
cmpl $0x8, %eax
sete %bl
movl %ecx, 0x4c(%rsp)
andl $0x20, %ebp
shrl $0x5, %ebp
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm4
jne 0x1c6332
jp 0x1c6332
ucomiss %xmm1, %xmm2
jbe 0x1c6332
movaps %xmm2, %xmm0
subss %xmm1, %xmm0
movss 0x1bed4f(%rip), %xmm3 # 0x385070
ucomiss %xmm0, %xmm3
jbe 0x1c6332
mulss 0x3020(%r14), %xmm0
movaps %xmm0, %xmm4
movl %r13d, %r15d
shrl $0x14, %r15d
movl 0x1c80(%r14), %eax
cmpl $0x1, %eax
movss %xmm2, 0x4(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm4, 0x30(%rsp)
jne 0x1c63d3
xorl %edi, %edi
callq 0xecb68
testb %al, %al
je 0x1c63bc
movss 0x484(%r14), %xmm0
ucomiss 0x1bce10(%rip), %xmm0 # 0x383180
jbe 0x1c63bc
movl %r15d, %eax
movss 0x3b4(%r14,%rax,4), %xmm5
cmpb $0x0, 0x13e(%r14)
je 0x1c6391
mulss 0x1becc7(%rip), %xmm5 # 0x385058
movss 0x4(%rsp), %xmm2
movaps 0x10(%rsp), %xmm1
movaps 0x30(%rsp), %xmm4
cmpb $0x1, 0x13d(%r14)
jne 0x1c649b
mulss 0x1bec59(%rip), %xmm5 # 0x385010
jmp 0x1c649b
movl 0x1c80(%r14), %eax
movss 0x4(%rsp), %xmm2
movaps 0x10(%rsp), %xmm1
movaps 0x30(%rsp), %xmm4
xorps %xmm5, %xmm5
cmpl $0x2, %eax
jne 0x1c649b
movq %r12, 0x20(%rsp)
xorl %r12d, %r12d
cmpl $0x8, 0xc(%rsp)
jne 0x1c6400
movq 0x40(%rsp), %rdi
movl $0x3, %esi
callq 0xe0a50
movl %eax, %r12d
movss 0x1bec24(%rip), %xmm0 # 0x38502c
movss 0x1bec00(%rip), %xmm1 # 0x385010
movl $0x3, %edi
movl $0x5, %esi
callq 0xe1f70
movlps %xmm0, 0x60(%rsp)
movl %r15d, %eax
movss 0x60(%rsp,%rax,4), %xmm5
testl %r12d, %r12d
js 0x1c6449
cmpl $0x9, %r12d
ja 0x1c6453
movl %r12d, %eax
leaq 0x1d2a3e(%rip), %rcx # 0x398e80
movss (%rcx,%rax,4), %xmm0
jmp 0x1c6475
movss 0x1d26c3(%rip), %xmm0 # 0x398b14
jmp 0x1c6475
negl %r12d
xorps %xmm1, %xmm1
cvtsi2ss %r12d, %xmm1
movss 0x1bebaa(%rip), %xmm0 # 0x385010
movaps %xmm5, 0x50(%rsp)
callq 0xe9b50
movaps 0x50(%rsp), %xmm5
movss 0x4(%rsp), %xmm2
movaps 0x10(%rsp), %xmm1
movaps 0x30(%rsp), %xmm4
movaps %xmm0, %xmm3
cmpless %xmm4, %xmm3
andps %xmm3, %xmm4
andnps %xmm0, %xmm3
orps %xmm3, %xmm4
movq 0x20(%rsp), %r12
andb %bpl, %bl
mulss %xmm4, %xmm5
testl %r13d, %r13d
je 0x1c64ae
xorps 0x1b6f32(%rip), %xmm5 # 0x37d3e0
testb %bl, %bl
je 0x1c64d3
movaps %xmm2, %xmm0
subss %xmm1, %xmm0
movss 0x1bebaf(%rip), %xmm3 # 0x385070
ucomiss %xmm0, %xmm3
jbe 0x1c64d3
ucomiss 0x1d264b(%rip), %xmm0 # 0x398b18
jbe 0x1c64d3
divss %xmm0, %xmm5
ucomiss %xmm1, %xmm2
movb 0x1c54(%r14), %al
ja 0x1c64e3
xorl %ecx, %ecx
jmp 0x1c650b
movss (%r12), %xmm0
ucomiss %xmm2, %xmm0
jb 0x1c64f6
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm5
ja 0x1c653e
xorps %xmm4, %xmm4
movaps %xmm5, %xmm3
cmpltps %xmm4, %xmm3
cmpleps %xmm1, %xmm0
andps %xmm3, %xmm0
movd %xmm0, %ecx
testb %al, %al
jne 0x1c653e
testb $0x1, %cl
jne 0x1c653e
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm5
jne 0x1c651e
jnp 0x1c6562
movss 0x301c(%r14), %xmm0
addss %xmm5, %xmm0
movss %xmm0, 0x301c(%r14)
movb $0x1, 0x3019(%r14)
jmp 0x1c656c
movl $0x0, 0x301c(%r14)
movb $0x0, 0x3019(%r14)
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, 0x3019(%r14)
je 0x1c6551
movss (%r12), %xmm3
testb %bl, %bl
movaps %xmm5, 0x50(%rsp)
je 0x1c6607
movq 0x40(%rsp), %rdi
movl $0x3, %esi
movaps %xmm3, 0x30(%rsp)
callq 0xe0a50
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
movss 0x1bea8a(%rip), %xmm0 # 0x38502c
callq 0xe9b50
movaps %xmm0, %xmm3
movss %xmm0, 0x20(%rsp)
xorps %xmm4, %xmm4
movl 0x8(%rsp), %ebp
movl %ebp, %edi
movaps 0x30(%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movss 0x4(%rsp), %xmm2
movl $0x1, %esi
callq 0xe5c00
movss %xmm0, 0x2c(%rsp)
addss 0x301c(%r14), %xmm0
xorps %xmm4, %xmm4
movl %ebp, %edi
movaps 0x10(%rsp), %xmm1
movss 0x4(%rsp), %xmm2
movl $0x1, %esi
movss 0x20(%rsp), %xmm3
callq 0xe7590
movaps %xmm0, %xmm3
jmp 0x1c661f
addss 0x301c(%r14), %xmm3
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rsp)
movss %xmm0, 0x20(%rsp)
testb $0x40, 0x4c(%rsp)
jne 0x1c663a
movq 0x40(%rsp), %rdi
movl 0x8(%rsp), %esi
movaps %xmm3, %xmm0
callq 0xea240
movaps %xmm0, %xmm3
movss 0x4(%rsp), %xmm2
movb $0x0, 0x3019(%r14)
testb %bl, %bl
je 0x1c6688
xorps %xmm4, %xmm4
movl 0x8(%rsp), %edi
movaps %xmm3, %xmm0
movaps 0x10(%rsp), %xmm1
movl $0x1, %esi
movaps %xmm3, 0x30(%rsp)
movss 0x20(%rsp), %xmm3
callq 0xe5c00
movaps 0x10(%rsp), %xmm4
movaps 0x30(%rsp), %xmm3
movss 0x4(%rsp), %xmm2
subss 0x2c(%rsp), %xmm0
jmp 0x1c6696
movaps %xmm3, %xmm0
subss (%r12), %xmm0
movaps 0x10(%rsp), %xmm4
movaps 0x50(%rsp), %xmm5
ucomiss %xmm4, %xmm2
movss 0x301c(%r14), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x301c(%r14)
xorps %xmm0, %xmm0
cmpeqss %xmm3, %xmm0
andnps %xmm3, %xmm0
movss (%r12), %xmm1
jbe 0x1c6706
ucomiss %xmm0, %xmm1
jne 0x1c66ce
jnp 0x1c6706
ucomiss %xmm0, %xmm4
ja 0x1c66e7
cmpl $0x8, 0xc(%rsp)
je 0x1c66ea
ucomiss %xmm1, %xmm0
jbe 0x1c66ea
xorps %xmm3, %xmm3
ucomiss %xmm5, %xmm3
jbe 0x1c66ea
movaps %xmm4, %xmm0
ucomiss %xmm2, %xmm0
ja 0x1c6703
cmpl $0x8, 0xc(%rsp)
je 0x1c6706
ucomiss %xmm0, %xmm1
jbe 0x1c6706
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm5
jbe 0x1c6706
movaps %xmm2, %xmm0
ucomiss %xmm0, %xmm1
jne 0x1c6711
jnp 0x1c6551
movss %xmm0, (%r12)
movb $0x1, %al
jmp 0x1c6553
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui_widgets.cpp
|
ImFileOpen(char const*, char const*)
|
ImFileHandle ImFileOpen(const char* filename, const char* mode)
{
#if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS) && !defined(__CYGWIN__) && !defined(__GNUC__)
// We need a fopen() wrapper because MSVC/Windows fopen doesn't handle UTF-8 filenames.
// Previously we used ImTextCountCharsFromUtf8/ImTextStrFromUtf8 here but we now need to support ImWchar16 and ImWchar32!
const int filename_wsize = ::MultiByteToWideChar(CP_UTF8, 0, filename, -1, NULL, 0);
const int mode_wsize = ::MultiByteToWideChar(CP_UTF8, 0, mode, -1, NULL, 0);
ImVector<ImWchar> buf;
buf.resize(filename_wsize + mode_wsize);
::MultiByteToWideChar(CP_UTF8, 0, filename, -1, (wchar_t*)&buf[0], filename_wsize);
::MultiByteToWideChar(CP_UTF8, 0, mode, -1, (wchar_t*)&buf[filename_wsize], mode_wsize);
return ::_wfopen((const wchar_t*)&buf[0], (const wchar_t*)&buf[filename_wsize]);
#else
return fopen(filename, mode);
#endif
}
|
jmp 0xe7540
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui.cpp
|
ImGui::PushID(int)
|
void ImGui::PushID(int int_id)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiID id = window->GetIDNoKeepAlive(int_id);
window->IDStack.push_back(id);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %esi
movq 0x289daa(%rip), %r15 # 0x46e2b8
movq (%r15), %rax
movq 0x1bf0(%rax), %rbx
movq %rbx, %rdi
callq 0xe0260
movl %eax, %ebp
movl 0x108(%rbx), %eax
cmpl 0x10c(%rbx), %eax
jne 0x1e4545
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x1e4551
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x1e4556
movq 0x110(%rbx), %r14
jmp 0x1e45dc
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x2, %rdi
movq (%r15), %rax
testq %rax, %rax
je 0x1e4572
incl 0x3b0(%rax)
movq 0x30b047(%rip), %rsi # 0x4ef5c0
callq *0x3024c9(%rip) # 0x4e6a48
movq %rax, %r14
movq 0x110(%rbx), %rsi
testq %rsi, %rsi
je 0x1e45c8
movslq 0x108(%rbx), %rdx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0xe51a0
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x1e45bb
movq (%r15), %rax
testq %rax, %rax
je 0x1e45bb
decl 0x3b0(%rax)
movq 0x30affe(%rip), %rsi # 0x4ef5c0
callq *0x302488(%rip) # 0x4e6a50
movq %r14, 0x110(%rbx)
movl %r12d, 0x10c(%rbx)
movl 0x108(%rbx), %eax
cltq
movl %ebp, (%r14,%rax,4)
incl 0x108(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/imgui/imgui.cpp
|
void ImPlot::PlotScatterEx<ImPlot::GetterYs<double>>(char const*, ImPlot::GetterYs<double> const&)
|
inline void PlotScatterEx(const char* label_id, const Getter& getter) {
if (BeginItem(label_id, ImPlotCol_MarkerOutline)) {
if (FitThisFrame()) {
for (int i = 0; i < getter.Count; ++i) {
ImPlotPoint p = getter(i);
FitPoint(p);
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
// render markers
ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
if (marker != ImPlotMarker_None) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderMarkers(getter, TransformerLinLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLin: RenderMarkers(getter, TransformerLogLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LinLog: RenderMarkers(getter, TransformerLinLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLog: RenderMarkers(getter, TransformerLogLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
}
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r12
movl $0x2, %esi
callq 0xebca0
testb %al, %al
je 0x21e481
movq 0x24c73a(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
cmpb $0x1, 0x218(%rbx)
jne 0x21dd3e
movl 0x8(%r12), %ecx
testl %ecx, %ecx
jle 0x21dd3e
xorl %ebp, %ebp
leaq 0x88(%rsp), %rbx
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd 0x10(%r12), %xmm0
addsd 0x18(%r12), %xmm0
movq (%r12), %rsi
movslq 0x24(%r12), %rdi
movl 0x20(%r12), %eax
addl %ebp, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
movsd (%rsi,%rax), %xmm1
movsd %xmm0, 0x88(%rsp)
movsd %xmm1, 0x90(%rsp)
movq %rbx, %rdi
callq 0xe2280
incl %ebp
movl 0x8(%r12), %ecx
cmpl %ecx, %ebp
jl 0x21dcd5
movq 0x24c6b5(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xe6e40
movq %rax, 0x78(%rsp)
movl 0x5cc(%rbx), %eax
xorl %r13d, %r13d
cmpl $-0x1, %eax
cmovnel %eax, %r13d
leaq 0x598(%rbx), %rdi
callq 0xe7f80
movl %eax, 0x40(%rsp)
leaq 0x5a8(%rbx), %rdi
callq 0xe7f80
movl %eax, 0x3c(%rsp)
movq 0x24c671(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
movq 0x28(%rcx), %rax
movslq 0x288(%rax), %rbp
movq %rcx, 0x80(%rsp)
movl 0x158(%rcx,%rbp,4), %eax
cmpq $0x3, %rax
ja 0x21e456
leaq 0x18bd53(%rip), %rcx # 0x3a9b00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x21e456
movq (%r12), %rsi
movsd 0x10(%r12), %xmm3
movsd 0x18(%r12), %xmm4
movl 0x20(%r12), %edi
movss 0x5d0(%rbx), %xmm0
movss %xmm0, 0x70(%rsp)
movss 0x5d4(%rbx), %xmm0
movss %xmm0, 0x68(%rsp)
movslq 0x24(%r12), %r8
movslq %r13d, %rax
movq %rax, 0x58(%rsp)
xorl %r13d, %r13d
xorpd %xmm5, %xmm5
movq %rbp, %r15
shlq $0x4, %r15
movq %rbp, %r12
shlq $0x7, %r12
movsd 0x1672d7(%rip), %xmm6 # 0x3850f8
movzbl 0x5ee(%rbx), %eax
movl %eax, 0x50(%rsp)
movzbl 0x5ef(%rbx), %eax
movl %eax, 0x48(%rsp)
movq 0x80(%rsp), %rcx
movsd %xmm3, 0xd0(%rsp)
movsd %xmm4, 0xc0(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0x60(%rsp)
movapd %xmm3, %xmm0
mulsd %xmm5, %xmm0
addsd %xmm4, %xmm0
leal (%rdi,%r13), %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq %r8, %rax
movq 0x28(%rcx), %rdx
cvtps2pd 0x164(%rcx,%r15), %xmm1
movhpd (%rsi,%rax), %xmm0 # xmm0 = xmm0[0],mem[0]
movsd 0x18(%rdx), %xmm2
movhpd 0x98(%rdx,%r12), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm0
movsd 0x198(%rcx), %xmm2
movhpd 0x1a0(%rcx,%rbp,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x88(%rsp)
movq 0x80(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x21def6
addsd %xmm6, %xmm5
incl %r13d
cmpl %r13d, %r14d
jne 0x21de5e
jmp 0x21e456
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x21dee1
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x21dee1
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x21dee1
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movss 0x70(%rsp), %xmm0
movl 0x50(%rsp), %edx
movl 0x40(%rsp), %ecx
movq %r8, %rbx
movl 0x48(%rsp), %r8d
movl 0x3c(%rsp), %r9d
movss 0x68(%rsp), %xmm1
movq 0x58(%rsp), %rax
movsd %xmm5, 0xa0(%rsp)
movq 0x24ed6d(%rip), %r10 # 0x46ccd0
callq *(%r10,%rax,8)
movsd 0x167189(%rip), %xmm6 # 0x3850f8
movsd 0xa0(%rsp), %xmm5
movq %rbx, %r8
movq 0xb0(%rsp), %rdi
movsd 0xc0(%rsp), %xmm4
movsd 0xd0(%rsp), %xmm3
movq 0x60(%rsp), %rsi
movq 0x24c44f(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
jmp 0x21dee1
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x21e456
movq (%r12), %rax
movq %rax, 0xd0(%rsp)
movups 0x10(%r12), %xmm0
movaps %xmm0, 0xc0(%rsp)
movups 0x18(%r12), %xmm0
movaps %xmm0, 0xb0(%rsp)
movl 0x20(%r12), %eax
movq %rax, 0x70(%rsp)
movss 0x5d0(%rbx), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x5d4(%rbx), %xmm0
movss %xmm0, 0x58(%rsp)
movslq 0x24(%r12), %rax
movq %rax, 0x68(%rsp)
movslq %r13d, %rax
movq %rax, 0x50(%rsp)
xorl %r13d, %r13d
xorpd %xmm4, %xmm4
movq %rbp, %r15
shlq $0x7, %r15
movq %rbp, %r12
shlq $0x4, %r12
movzbl 0x5ee(%rbx), %eax
movl %eax, 0x48(%rsp)
movzbl 0x5ef(%rbx), %eax
movl %eax, 0x44(%rsp)
movapd %xmm4, 0xa0(%rsp)
movq 0x70(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x68(%rsp), %rax
movq 0xd0(%rsp), %rcx
movsd (%rcx,%rax), %xmm0
movq 0x24c374(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
movq 0x28(%rbx), %rax
divsd 0x98(%rax,%r15), %xmm0
callq 0xe2ca0
movaps 0xa0(%rsp), %xmm4
divsd 0x1c0(%rbx,%rbp,8), %xmm0
movq 0x28(%rbx), %rax
movsd 0x98(%rax,%r15), %xmm1
cvtsd2ss %xmm0, %xmm0
movsd 0xa0(%rax,%r15), %xmm2
subsd %xmm1, %xmm2
movapd 0xc0(%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtss2sd %xmm0, %xmm0
movaps %xmm4, %xmm2
movlhps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm3, %xmm2
movapd 0xb0(%rsp), %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
cvtps2pd 0x164(%rbx,%r12), %xmm3
addpd %xmm2, %xmm0
movsd 0x18(%rax), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm0
movsd 0x198(%rbx), %xmm1
movhpd 0x1a0(%rbx,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x88(%rsp)
movq 0x80(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x21e159
addsd 0x166fb0(%rip), %xmm4 # 0x3850f8
incl %r13d
cmpl %r13d, %r14d
jne 0x21e042
jmp 0x21e456
movsd 0x2bc(%rax), %xmm1
movaps %xmm1, %xmm2
shufps $0xe1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[2,3]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
ucomiss %xmm0, %xmm1
seta %cl
cmpleps %xmm0, %xmm2
pextrw $0x2, %xmm2, %edx
testb $0x1, %dl
je 0x21e140
testb %cl, %cl
je 0x21e140
movss 0x2c4(%rax), %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm0, %xmm1
jbe 0x21e140
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movss 0x60(%rsp), %xmm0
movl 0x48(%rsp), %edx
movl 0x40(%rsp), %ecx
movl 0x44(%rsp), %r8d
movl 0x3c(%rsp), %r9d
movss 0x58(%rsp), %xmm1
movq 0x50(%rsp), %rax
movq 0x252044(%rip), %r10 # 0x470210
callq *(%r10,%rax,8)
movaps 0xa0(%rsp), %xmm4
jmp 0x21e140
movzbl 0x5ee(%rbx), %ecx
movss 0x5d0(%rbx), %xmm0
movss 0x5d4(%rbx), %xmm1
movzbl 0x5ef(%rbx), %r9d
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movupd (%r12), %xmm2
movupd 0x10(%r12), %xmm3
movupd %xmm3, 0x10(%rsp)
movupd %xmm2, (%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl %ebp, %edi
movq 0x78(%rsp), %rsi
movl %r13d, %edx
movl 0x40(%rsp), %r8d
callq 0xe7320
jmp 0x21e456
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x21e456
movq (%r12), %rax
movq %rax, 0xc0(%rsp)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0x18(%r12), %xmm0
movsd %xmm0, 0x70(%rsp)
movl 0x20(%r12), %eax
movq %rax, 0x68(%rsp)
movss 0x5d0(%rbx), %xmm0
movss %xmm0, 0x58(%rsp)
movss 0x5d4(%rbx), %xmm0
movss %xmm0, 0x50(%rsp)
movslq 0x24(%r12), %rax
movq %rax, 0x60(%rsp)
movslq %r13d, %rax
movq %rax, 0x48(%rsp)
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
movq %rbp, %r15
shlq $0x4, %r15
movq %rbp, %r12
shlq $0x7, %r12
movzbl 0x5ee(%rbx), %eax
movl %eax, 0x44(%rsp)
movzbl 0x5ef(%rbx), %eax
movl %eax, 0x9c(%rsp)
movsd 0xb0(%rsp), %xmm0
movsd %xmm1, 0xa0(%rsp)
mulsd %xmm1, %xmm0
addsd 0x70(%rsp), %xmm0
movq 0x68(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x60(%rsp), %rax
movq 0x24c0d4(%rip), %rcx # 0x46a3f0
movq (%rcx), %rbx
movq 0x28(%rbx), %rcx
divsd 0x18(%rcx), %xmm0
movq 0xc0(%rsp), %rcx
movsd (%rcx,%rax), %xmm1
movaps %xmm1, 0xd0(%rsp)
callq 0xe2ca0
divsd 0x1b8(%rbx), %xmm0
movq 0x28(%rbx), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%rbx,%r15), %xmm2
unpcklpd 0xd0(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movhpd 0x98(%rax,%r12), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%rbx), %xmm1
movhpd 0x1a0(%rbx,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x88(%rsp)
movq 0x80(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x21e3e9
movsd 0xa0(%rsp), %xmm1
addsd 0x166d1d(%rip), %xmm1 # 0x3850f8
incl %r13d
cmpl %r13d, %r14d
jne 0x21e2dc
jmp 0x21e456
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x21e3ca
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x21e3ca
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x21e3ca
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movss 0x58(%rsp), %xmm0
movl 0x44(%rsp), %edx
movl 0x40(%rsp), %ecx
movl 0x9c(%rsp), %r8d
movl 0x3c(%rsp), %r9d
movss 0x50(%rsp), %xmm1
movq 0x48(%rsp), %rax
movq 0x24e433(%rip), %r10 # 0x46c880
callq *(%r10,%rax,8)
jmp 0x21e3ca
movq 0x24bf93(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotScatter<short>(char const*, short const*, short const*, int, int, int)
|
void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, int offset, int stride) {
GetterXsYs<T> getter(xs,ys,count,offset,stride);
return PlotScatterEx(label_id, getter);
}
|
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
testl %ecx, %ecx
je 0x21f39b
movl %r8d, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
jmp 0x21f39d
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x14(%rsi)
movl %r9d, 0x18(%rsi)
callq 0xe7c10
addq $0x28, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotScatter<int>(char const*, int const*, int const*, int, int, int)
|
void PlotScatter(const char* label_id, const T* xs, const T* ys, int count, int offset, int stride) {
GetterXsYs<T> getter(xs,ys,count,offset,stride);
return PlotScatterEx(label_id, getter);
}
|
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
testl %ecx, %ecx
je 0x22027a
movl %r8d, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
jmp 0x22027c
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x14(%rsi)
movl %r9d, 0x18(%rsi)
callq 0xe70a0
addq $0x28, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotShaded<unsigned int>(char const*, unsigned int const*, unsigned int const*, int, double, int, int)
|
void PlotShaded(const char* label_id, const T* xs, const T* ys, int count, double y_ref, int offset, int stride) {
GetterXsYs<T> getter1(xs, ys, count, offset, stride);
GetterXsYRef<T> getter2(xs, y_ref, count, offset, stride);
PlotShadedEx(label_id, getter1, getter2);
}
|
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
testl %ecx, %ecx
je 0x230b2c
movl %r8d, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
jmp 0x230b2e
xorl %edx, %edx
leaq 0x8(%rsp), %rax
movl %edx, 0x14(%rax)
movl %r9d, 0x18(%rax)
leaq 0x28(%rsp), %r8
movq %rsi, (%r8)
movsd %xmm0, 0x8(%r8)
movl %ecx, 0x10(%r8)
movl %edx, 0x14(%r8)
movl %r9d, 0x18(%r8)
movq %rax, %rsi
movq %r8, %rdx
callq 0xe1bb0
addq $0x48, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotBarsHEx<ImPlot::GetterXsYs<double>, double>(char const*, ImPlot::GetterXsYs<double> const&, double)
|
void PlotBarsHEx(const char* label_id, const Getter& getter, THeight height) {
if (BeginItem(label_id, ImPlotCol_Fill)) {
const THeight half_height = height / 2;
if (FitThisFrame()) {
for (int i = 0; i < getter.Count; ++i) {
ImPlotPoint p = getter(i);
FitPoint(ImPlotPoint(0, p.y - half_height));
FitPoint(ImPlotPoint(p.x, p.y + half_height));
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_Fill]);
bool rend_line = s.RenderLine;
if (s.RenderFill && col_line == col_fill)
rend_line = false;
for (int i = 0; i < getter.Count; ++i) {
ImPlotPoint p = getter(i);
if (p.x == 0)
continue;
ImVec2 a = PlotToPixels(0, p.y - half_height);
ImVec2 b = PlotToPixels(p.x, p.y + half_height);
if (s.RenderFill)
DrawList.AddRectFilled(a, b, col_fill);
if (rend_line)
DrawList.AddRect(a, b, col_line, 0, ImDrawCornerFlags_All, s.LineWeight);
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movl $0x1, %esi
callq 0xebca0
testb %al, %al
je 0x23a007
movsd (%rsp), %xmm0
mulsd 0x16cf86(%rip), %xmm0 # 0x3a6d68
movsd %xmm0, (%rsp)
movq 0x230602(%rip), %r15 # 0x46a3f0
movq (%r15), %r12
cmpb $0x1, 0x218(%r12)
jne 0x239e95
movl 0x10(%rbx), %ecx
testl %ecx, %ecx
jle 0x239e95
xorl %ebp, %ebp
leaq 0x20(%rsp), %r14
movslq 0x18(%rbx), %rsi
movl 0x14(%rbx), %eax
addl %ebp, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movsd (%rcx,%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd (%rdx,%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
subsd (%rsp), %xmm0
movq $0x0, 0x20(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
callq 0xe2280
movsd 0x10(%rsp), %xmm1
addsd (%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x28(%rsp)
movq %r14, %rdi
callq 0xe2280
incl %ebp
movl 0x10(%rbx), %ecx
cmpl %ecx, %ebp
jl 0x239e12
movq (%r15), %r12
leaq 0x578(%r12), %r15
callq 0xe6e40
movq %rax, %r14
movq %r15, %rdi
callq 0xe7f80
movl %eax, 0xc(%rsp)
leaq 0x588(%r12), %rdi
callq 0xe7f80
movl 0x10(%rbx), %ecx
testl %ecx, %ecx
movsd (%rsp), %xmm0
jle 0x239fdc
movl %eax, %r15d
movb 0x5ed(%r12), %r13b
cmpl %eax, 0xc(%rsp)
setne %al
xorb $0x1, %r13b
orb %al, %r13b
andb 0x5ec(%r12), %r13b
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movq (%rbx), %rsi
movslq 0x18(%rbx), %rdi
movl 0x14(%rbx), %eax
addl %ebp, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
movsd (%rsi,%rax), %xmm2
ucomisd %xmm1, %xmm2
jne 0x239f22
jnp 0x239fd2
movq 0x8(%rbx), %rcx
movsd (%rcx,%rax), %xmm1
movsd %xmm1, 0x18(%rsp)
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movsd %xmm2, 0x10(%rsp)
callq 0xecad0
movlpd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm1
addsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movlps %xmm0, 0x30(%rsp)
cmpb $0x1, 0x5ed(%r12)
jne 0x239f98
xorps %xmm0, %xmm0
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl %r15d, %ecx
movl $0xf, %r8d
callq 0xe3d60
testb %r13b, %r13b
je 0x239fc6
movss 0x5c8(%r12), %xmm1
xorps %xmm0, %xmm0
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl $0xf, %r8d
callq 0xe6c00
movl 0x10(%rbx), %ecx
movsd (%rsp), %xmm0
xorpd %xmm1, %xmm1
incl %ebp
cmpl %ecx, %ebp
jl 0x239ef5
movq 0x23040d(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBarsEx<ImPlot::GetterError<signed char>>(char const*, ImPlot::GetterError<signed char> const&)
|
void PlotErrorBarsEx(const char* label_id, const Getter& getter) {
if (BeginItem(label_id)) {
if (FitThisFrame()) {
for (int i = 0; i < getter.Count; ++i) {
ImPlotPointError e = getter(i);
FitPoint(ImPlotPoint(e.X , e.Y - e.Neg));
FitPoint(ImPlotPoint(e.X , e.Y + e.Pos ));
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
const ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_ErrorBar]);
const bool rend_whisker = s.ErrorBarSize > 0;
const float half_whisker = s.ErrorBarSize * 0.5f;
for (int i = 0; i < getter.Count; ++i) {
ImPlotPointError e = getter(i);
ImVec2 p1 = PlotToPixels(e.X, e.Y - e.Neg);
ImVec2 p2 = PlotToPixels(e.X, e.Y + e.Pos);
DrawList.AddLine(p1,p2,col, s.ErrorBarWeight);
if (rend_whisker) {
DrawList.AddLine(p1 - ImVec2(half_whisker, 0), p1 + ImVec2(half_whisker, 0), col, s.ErrorBarWeight);
DrawList.AddLine(p2 - ImVec2(half_whisker, 0), p2 + ImVec2(half_whisker, 0), col, s.ErrorBarWeight);
}
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xebca0
testb %al, %al
je 0x23a355
movq 0x230360(%rip), %r15 # 0x46a3f0
movq (%r15), %r12
cmpb $0x1, 0x218(%r12)
jne 0x23a16c
movl 0x20(%rbx), %ecx
testl %ecx, %ecx
jle 0x23a16c
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
movslq 0x28(%rbx), %rsi
movl 0x24(%rbx), %eax
addl %ebp, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%rbx), %rcx
movsbl (%rcx,%rax), %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
movsd %xmm2, 0x8(%rsp)
movq 0x8(%rbx), %rcx
movsbl (%rcx,%rax), %ecx
xorps %xmm3, %xmm3
cvtsi2sd %ecx, %xmm3
movsd %xmm3, 0x10(%rsp)
movq 0x10(%rbx), %rcx
movsbl (%rcx,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movq 0x18(%rbx), %rcx
movsbl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm1, 0x18(%rsp)
movapd %xmm3, %xmm1
subsd %xmm0, %xmm1
movsd %xmm2, 0x28(%rsp)
movsd %xmm1, 0x30(%rsp)
movq %r14, %rdi
callq 0xe2280
movsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %r14, %rdi
callq 0xe2280
incl %ebp
movl 0x20(%rbx), %ecx
cmpl %ecx, %ebp
jl 0x23a0b4
movq (%r15), %r12
callq 0xe6e40
movq %rax, %r14
leaq 0x5b8(%r12), %rdi
callq 0xe7f80
movl 0x20(%rbx), %ecx
testl %ecx, %ecx
jle 0x23a32a
movl %eax, %ebp
movss 0x5dc(%r12), %xmm0
movss 0x148fe8(%rip), %xmm1 # 0x383188
movss %xmm0, 0x3c(%rsp)
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
movaps %xmm1, 0x60(%rsp)
movss %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
movaps %xmm0, 0x50(%rsp)
xorl %r13d, %r13d
movslq 0x28(%rbx), %rsi
movl 0x24(%rbx), %eax
addl %r13d, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movsbl (%rcx,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rsp)
movsbl (%rdx,%rax), %ecx
xorps %xmm3, %xmm3
cvtsi2sd %ecx, %xmm3
movsd %xmm3, 0x10(%rsp)
movq 0x10(%rbx), %rcx
movsbl (%rcx,%rax), %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
movq 0x18(%rbx), %rcx
movsbl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm1, 0x18(%rsp)
movapd %xmm3, %xmm1
subsd %xmm2, %xmm1
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movlpd %xmm0, 0x28(%rsp)
movsd 0x18(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movlps %xmm0, 0x48(%rsp)
movss 0x5e0(%r12), %xmm0
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movl %ebp, %ecx
callq 0xe5ce0
movss 0x3c(%rsp), %xmm0
ucomiss 0x14adab(%rip), %xmm0 # 0x385034
jbe 0x23a31b
movsd 0x28(%rsp), %xmm0
movaps %xmm0, %xmm1
subss 0x60(%rsp), %xmm1
movlps %xmm1, 0x20(%rsp)
addps 0x50(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movss 0x5e0(%r12), %xmm0
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
movl %ebp, %r15d
movq %r14, %rbp
movq %r12, %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdx
movl %r15d, %ecx
callq 0xe5ce0
movsd 0x48(%rsp), %xmm0
movaps %xmm0, %xmm1
subss 0x60(%rsp), %xmm1
movlps %xmm1, 0x20(%rsp)
addps 0x50(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movss 0x5e0(%r14), %xmm0
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
movq %r12, %rdx
movq %r14, %r12
movq %rbp, %r14
movl %r15d, %ebp
movl %r15d, %ecx
callq 0xe5ce0
incl %r13d
movl 0x20(%rbx), %ecx
cmpl %ecx, %r13d
jl 0x23a1be
movq 0x2300bf(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBars<float>(char const*, float const*, float const*, float const*, int, int, int)
|
void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset, int stride) {
GetterError<T> getter(xs, ys, err, err, count, offset, stride);
PlotErrorBarsEx(label_id, getter);
}
|
subq $0x38, %rsp
movl 0x40(%rsp), %r10d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x28(%rsp)
testl %r8d, %r8d
je 0x23bb2c
movl %r9d, %eax
cltd
idivl %r8d
leal (%rdx,%r8), %eax
cltd
idivl %r8d
jmp 0x23bb2e
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
callq 0xe25f0
addq $0x38, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBars<double>(char const*, double const*, double const*, double const*, int, int, int)
|
void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* err, int count, int offset, int stride) {
GetterError<T> getter(xs, ys, err, err, count, offset, stride);
PlotErrorBarsEx(label_id, getter);
}
|
subq $0x38, %rsp
movl 0x40(%rsp), %r10d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x28(%rsp)
testl %r8d, %r8d
je 0x23be5f
movl %r9d, %eax
cltd
idivl %r8d
leal (%rdx,%r8), %eax
cltd
idivl %r8d
jmp 0x23be61
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
callq 0xe5ae0
addq $0x38, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBars<int>(char const*, int const*, int const*, int const*, int const*, int, int, int)
|
void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) {
GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
PlotErrorBarsEx(label_id, getter);
}
|
subq $0x38, %rsp
movl 0x48(%rsp), %r10d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x28(%rsp)
testl %r9d, %r9d
je 0x23c29d
movl 0x40(%rsp), %eax
cltd
idivl %r9d
leal (%rdx,%r9), %eax
cltd
idivl %r9d
jmp 0x23c29f
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
callq 0xe00b0
addq $0x38, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBars<unsigned long long>(char const*, unsigned long long const*, unsigned long long const*, unsigned long long const*, unsigned long long const*, int, int, int)
|
void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) {
GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
PlotErrorBarsEx(label_id, getter);
}
|
subq $0x38, %rsp
movl 0x48(%rsp), %r10d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x28(%rsp)
testl %r9d, %r9d
je 0x23c390
movl 0x40(%rsp), %eax
cltd
idivl %r9d
leal (%rdx,%r9), %eax
cltd
idivl %r9d
jmp 0x23c392
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
callq 0xe87c0
addq $0x38, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBarsHEx<ImPlot::GetterError<long long>>(char const*, ImPlot::GetterError<long long> const&)
|
void PlotErrorBarsHEx(const char* label_id, const Getter& getter) {
if (BeginItem(label_id)) {
if (FitThisFrame()) {
for (int i = 0; i < getter.Count; ++i) {
ImPlotPointError e = getter(i);
FitPoint(ImPlotPoint(e.X - e.Neg, e.Y));
FitPoint(ImPlotPoint(e.X + e.Pos, e.Y));
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
const ImU32 col = ImGui::GetColorU32(s.Colors[ImPlotCol_ErrorBar]);
const bool rend_whisker = s.ErrorBarSize > 0;
const float half_whisker = s.ErrorBarSize * 0.5f;
for (int i = 0; i < getter.Count; ++i) {
ImPlotPointError e = getter(i);
ImVec2 p1 = PlotToPixels(e.X - e.Neg, e.Y);
ImVec2 p2 = PlotToPixels(e.X + e.Pos, e.Y);
DrawList.AddLine(p1, p2, col, s.ErrorBarWeight);
if (rend_whisker) {
DrawList.AddLine(p1 - ImVec2(0, half_whisker), p1 + ImVec2(0, half_whisker), col, s.ErrorBarWeight);
DrawList.AddLine(p2 - ImVec2(0, half_whisker), p2 + ImVec2(0, half_whisker), col, s.ErrorBarWeight);
}
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xebca0
testb %al, %al
je 0x23dbe4
movq 0x22cada(%rip), %r15 # 0x46a3f0
movq (%r15), %r12
cmpb $0x1, 0x218(%r12)
jne 0x23d9ea
movl 0x20(%rbx), %ecx
testl %ecx, %ecx
jle 0x23d9ea
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
movslq 0x28(%rbx), %rsi
movl 0x24(%rbx), %eax
addl %ebp, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
xorps %xmm3, %xmm3
cvtsi2sdq (%rcx,%rax), %xmm3
movsd %xmm3, 0x10(%rsp)
xorps %xmm2, %xmm2
cvtsi2sdq (%rdx,%rax), %xmm2
movsd %xmm2, 0x8(%rsp)
movq 0x10(%rbx), %rcx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
movq 0x18(%rbx), %rcx
xorps %xmm1, %xmm1
cvtsi2sdq (%rcx,%rax), %xmm1
movsd %xmm1, 0x18(%rsp)
movapd %xmm3, %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x30(%rsp)
movq %r14, %rdi
callq 0xe2280
movsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq %r14, %rdi
callq 0xe2280
incl %ebp
movl 0x20(%rbx), %ecx
cmpl %ecx, %ebp
jl 0x23d93a
movq (%r15), %r12
callq 0xe6e40
movq %rax, %r14
leaq 0x5b8(%r12), %rdi
callq 0xe7f80
movl 0x20(%rbx), %ecx
testl %ecx, %ecx
jle 0x23dbb9
movl %eax, %ebp
movss 0x5dc(%r12), %xmm0
movss 0x14576a(%rip), %xmm1 # 0x383188
movss %xmm0, 0x3c(%rsp)
mulss %xmm0, %xmm1
movaps %xmm1, 0x60(%rsp)
movq %xmm1, %xmm1 # xmm1 = xmm1[0],zero
xorps %xmm0, %xmm0
shufps $0xe2, %xmm0, %xmm1 # xmm1 = xmm1[2,0],xmm0[2,3]
movaps %xmm1, 0x50(%rsp)
xorl %r13d, %r13d
movslq 0x28(%rbx), %rsi
movl 0x24(%rbx), %eax
addl %r13d, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
xorps %xmm3, %xmm3
cvtsi2sdq (%rcx,%rax), %xmm3
movsd %xmm3, 0x10(%rsp)
xorps %xmm1, %xmm1
cvtsi2sdq (%rdx,%rax), %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x10(%rbx), %rcx
xorps %xmm2, %xmm2
cvtsi2sdq (%rcx,%rax), %xmm2
movq 0x18(%rbx), %rcx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm3, %xmm0
subsd %xmm2, %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movlpd %xmm0, 0x28(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movlpd %xmm0, 0x48(%rsp)
movss 0x5e0(%r12), %xmm0
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movl %ebp, %ecx
callq 0xe5ce0
movss 0x3c(%rsp), %xmm0
ucomiss 0x147530(%rip), %xmm0 # 0x385034
jbe 0x23dbaa
movsd 0x28(%rsp), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
subss 0x60(%rsp), %xmm1
movaps 0x50(%rsp), %xmm2
addps %xmm0, %xmm2
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, 0x20(%rsp)
movlps %xmm2, 0x40(%rsp)
movss 0x5e0(%r12), %xmm0
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
movl %ebp, %r15d
movq %r14, %rbp
movq %r12, %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdx
movl %r15d, %ecx
callq 0xe5ce0
movsd 0x48(%rsp), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
subss 0x60(%rsp), %xmm1
movaps 0x50(%rsp), %xmm2
addps %xmm0, %xmm2
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movlps %xmm0, 0x20(%rsp)
movlps %xmm2, 0x40(%rsp)
movss 0x5e0(%r14), %xmm0
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
movq %r12, %rdx
movq %r14, %r12
movq %rbp, %r14
movl %r15d, %ebp
movl %r15d, %ecx
callq 0xe5ce0
incl %r13d
movl 0x20(%rbx), %ecx
cmpl %ecx, %r13d
jl 0x23da40
movq 0x22c830(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBarsH<signed char>(char const*, signed char const*, signed char const*, signed char const*, signed char const*, int, int, int)
|
void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) {
GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
PlotErrorBarsHEx(label_id, getter);
}
|
subq $0x38, %rsp
movl 0x48(%rsp), %r10d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x28(%rsp)
testl %r9d, %r9d
je 0x23e684
movl 0x40(%rsp), %eax
cltd
idivl %r9d
leal (%rdx,%r9), %eax
cltd
idivl %r9d
jmp 0x23e686
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
callq 0xe50b0
addq $0x38, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBarsH<unsigned int>(char const*, unsigned int const*, unsigned int const*, unsigned int const*, unsigned int const*, int, int, int)
|
void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) {
GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
PlotErrorBarsHEx(label_id, getter);
}
|
subq $0x38, %rsp
movl 0x48(%rsp), %r10d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x28(%rsp)
testl %r9d, %r9d
je 0x23e819
movl 0x40(%rsp), %eax
cltd
idivl %r9d
leal (%rdx,%r9), %eax
cltd
idivl %r9d
jmp 0x23e81b
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
callq 0xe1830
addq $0x38, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotErrorBarsH<unsigned long long>(char const*, unsigned long long const*, unsigned long long const*, unsigned long long const*, unsigned long long const*, int, int, int)
|
void PlotErrorBarsH(const char* label_id, const T* xs, const T* ys, const T* neg, const T* pos, int count, int offset, int stride) {
GetterError<T> getter(xs, ys, neg, pos, count, offset, stride);
PlotErrorBarsHEx(label_id, getter);
}
|
subq $0x38, %rsp
movl 0x48(%rsp), %r10d
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x28(%rsp)
testl %r9d, %r9d
je 0x23e8bb
movl 0x40(%rsp), %eax
cltd
idivl %r9d
leal (%rdx,%r9), %eax
cltd
idivl %r9d
jmp 0x23e8bd
xorl %edx, %edx
leaq 0x8(%rsp), %rsi
movl %edx, 0x24(%rsi)
movl %r10d, 0x28(%rsi)
callq 0xea840
addq $0x38, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStemsEx<ImPlot::GetterYs<short>, ImPlot::GetterYRef>(char const*, ImPlot::GetterYs<short> const&, ImPlot::GetterYRef const&)
|
inline void PlotStemsEx(const char* label_id, const GetterM& get_mark, const GetterB& get_base) {
if (BeginItem(label_id, ImPlotCol_Line)) {
if (FitThisFrame()) {
for (int i = 0; i < get_base.Count; ++i) {
FitPoint(get_mark(i));
FitPoint(get_base(i));
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
// render stems
if (s.RenderLine) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderLineSegments(get_mark, get_base, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLin: RenderLineSegments(get_mark, get_base, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LinLog: RenderLineSegments(get_mark, get_base, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLog: RenderLineSegments(get_mark, get_base, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
}
}
// render markers
ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
if (marker != ImPlotMarker_None) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderMarkers(get_mark, TransformerLinLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLin: RenderMarkers(get_mark, TransformerLogLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LinLog: RenderMarkers(get_mark, TransformerLinLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLog: RenderMarkers(get_mark, TransformerLogLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
}
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rsi, %r12
xorl %esi, %esi
callq 0xebca0
testb %al, %al
je 0x240667
movq 0x22a69f(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
cmpb $0x1, 0x218(%rbp)
jne 0x23fe1b
cmpl $0x0, 0x8(%r14)
jle 0x23fe1b
xorl %ebp, %ebp
leaq 0x50(%rsp), %rbx
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd %xmm1, 0x60(%rsp)
movsd 0x10(%r12), %xmm0
mulsd %xmm1, %xmm0
addsd 0x18(%r12), %xmm0
movq (%r12), %rcx
movl 0x8(%r12), %esi
movslq 0x24(%r12), %rdi
movl 0x20(%r12), %eax
addl %ebp, %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movswl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x58(%rsp)
movq %rbx, %rdi
callq 0xe2280
movsd 0x60(%rsp), %xmm0
mulsd 0x10(%r14), %xmm0
addsd 0x18(%r14), %xmm0
movapd %xmm0, %xmm1
movsd (%r14), %xmm0
movsd %xmm1, 0x50(%rsp)
movsd %xmm0, 0x58(%rsp)
movq %rbx, %rdi
callq 0xe2280
incl %ebp
cmpl 0x8(%r14), %ebp
jl 0x23fd73
movq 0x22a5d8(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
callq 0xe6e40
movq %rax, 0x40(%rsp)
cmpb $0x1, 0x5ec(%rbp)
jne 0x23ff02
leaq 0x578(%rbp), %rdi
callq 0xe7f80
movq 0x22a5ab(%rip), %rcx # 0x46a3f0
movq (%rcx), %rdx
movq 0x28(%rdx), %rcx
movslq 0x288(%rcx), %rcx
movl 0x158(%rdx,%rcx,4), %edx
cmpq $0x3, %rdx
ja 0x23ff02
leaq 0x16a1ed(%rip), %rsi # 0x3aa058
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xeb400
jmp 0x23ff02
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xe5fe0
jmp 0x23ff02
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xe1720
jmp 0x23ff02
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xe3a50
movl 0x5cc(%rbp), %eax
xorl %r13d, %r13d
cmpl $-0x1, %eax
cmovnel %eax, %r13d
leaq 0x598(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x3c(%rsp)
leaq 0x5a8(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x38(%rsp)
movq 0x22a4b7(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
movq 0x28(%rcx), %rax
movslq 0x288(%rax), %rbx
movq %rcx, 0x60(%rsp)
movl 0x158(%rcx,%rbx,4), %eax
cmpq $0x3, %rax
ja 0x24063c
leaq 0x16a104(%rip), %rcx # 0x3aa068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x24063c
movq (%r12), %rsi
movsd 0x10(%r12), %xmm3
movsd 0x18(%r12), %xmm4
movl 0x20(%r12), %edi
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x90(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x88(%rsp)
movslq 0x24(%r12), %r8
movslq %r13d, %rax
movq %rax, 0x78(%rsp)
xorl %r13d, %r13d
xorpd %xmm5, %xmm5
movq %rbx, %r15
shlq $0x4, %r15
movq %rbx, %r12
shlq $0x7, %r12
movsd 0x14511a(%rip), %xmm6 # 0x3850f8
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x70(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x68(%rsp)
movq 0x60(%rsp), %rcx
movsd %xmm3, 0xd0(%rsp)
movsd %xmm4, 0xc0(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0x80(%rsp)
movapd %xmm3, %xmm0
mulsd %xmm5, %xmm0
addsd %xmm4, %xmm0
leal (%rdi,%r13), %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq %r8, %rax
movswl (%rsi,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movq 0x28(%rcx), %rax
cvtps2pd 0x164(%rcx,%r15), %xmm1
movsd 0x18(%rax), %xmm2
movhpd 0x98(%rax,%r12), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm0
movsd 0x198(%rcx), %xmm2
movhpd 0x1a0(%rcx,%rbx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x2400b7
addsd %xmm6, %xmm5
incl %r13d
cmpl %r13d, %r14d
jne 0x24001b
jmp 0x24063c
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x2400a2
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x2400a2
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2400a2
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movss 0x90(%rsp), %xmm0
movl 0x70(%rsp), %edx
movl 0x3c(%rsp), %ecx
movq %r8, %rbp
movl 0x68(%rsp), %r8d
movl 0x38(%rsp), %r9d
movss 0x88(%rsp), %xmm1
movq 0x78(%rsp), %rax
movsd %xmm5, 0xa0(%rsp)
movq 0x22f801(%rip), %r10 # 0x46f928
callq *(%r10,%rax,8)
movsd 0x144fc5(%rip), %xmm6 # 0x3850f8
movsd 0xa0(%rsp), %xmm5
movq %rbp, %r8
movq 0xb0(%rsp), %rdi
movsd 0xc0(%rsp), %xmm4
movsd 0xd0(%rsp), %xmm3
movq 0x80(%rsp), %rsi
movq 0x22a288(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
jmp 0x2400a2
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x24063c
movq (%r12), %rax
movq %rax, 0xd0(%rsp)
movups 0x10(%r12), %xmm0
movaps %xmm0, 0xc0(%rsp)
movups 0x18(%r12), %xmm0
movaps %xmm0, 0xb0(%rsp)
movl 0x20(%r12), %eax
movq %rax, 0x90(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x80(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x78(%rsp)
movslq 0x24(%r12), %rax
movq %rax, 0x88(%rsp)
movslq %r13d, %rax
movq %rax, 0x70(%rsp)
xorl %r13d, %r13d
xorpd %xmm4, %xmm4
movq %rbx, %r15
shlq $0x7, %r15
movq %rbx, %r12
shlq $0x4, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x68(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x4c(%rsp)
movapd %xmm4, 0xa0(%rsp)
movq 0x90(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x88(%rsp), %rax
movq 0xd0(%rsp), %rcx
movswl (%rcx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x22a198(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x98(%rax,%r15), %xmm0
callq 0xe2ca0
movaps 0xa0(%rsp), %xmm4
divsd 0x1c0(%rbp,%rbx,8), %xmm0
movq 0x28(%rbp), %rax
movsd 0x98(%rax,%r15), %xmm1
cvtsd2ss %xmm0, %xmm0
movsd 0xa0(%rax,%r15), %xmm2
subsd %xmm1, %xmm2
movapd 0xc0(%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtss2sd %xmm0, %xmm0
movaps %xmm4, %xmm2
movlhps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm3, %xmm2
movapd 0xb0(%rsp), %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
cvtps2pd 0x164(%rbp,%r12), %xmm3
addpd %xmm2, %xmm0
movsd 0x18(%rax), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm0
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x24032f
addsd 0x144dda(%rip), %xmm4 # 0x3850f8
incl %r13d
cmpl %r13d, %r14d
jne 0x240212
jmp 0x24063c
movsd 0x2bc(%rax), %xmm1
movaps %xmm1, %xmm2
shufps $0xe1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[2,3]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
ucomiss %xmm0, %xmm1
seta %cl
cmpleps %xmm0, %xmm2
pextrw $0x2, %xmm2, %edx
testb $0x1, %dl
je 0x240316
testb %cl, %cl
je 0x240316
movss 0x2c4(%rax), %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm0, %xmm1
jbe 0x240316
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movss 0x80(%rsp), %xmm0
movl 0x68(%rsp), %edx
movl 0x3c(%rsp), %ecx
movl 0x4c(%rsp), %r8d
movl 0x38(%rsp), %r9d
movss 0x78(%rsp), %xmm1
movq 0x70(%rsp), %rax
movq 0x22aa3e(%rip), %r10 # 0x46ade0
callq *(%r10,%rax,8)
movaps 0xa0(%rsp), %xmm4
jmp 0x240316
movzbl 0x5ee(%rbp), %ecx
movss 0x5d0(%rbp), %xmm0
movss 0x5d4(%rbp), %xmm1
movzbl 0x5ef(%rbp), %r9d
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movupd (%r12), %xmm2
movupd 0x10(%r12), %xmm3
movupd %xmm3, 0x10(%rsp)
movupd %xmm2, (%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x28(%rsp)
movl %ebx, %edi
movq 0x40(%rsp), %rsi
movl %r13d, %edx
movl 0x3c(%rsp), %r8d
callq 0xec1a0
jmp 0x24063c
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x24063c
movq (%r12), %rax
movq %rax, 0xc0(%rsp)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0x18(%r12), %xmm0
movsd %xmm0, 0x90(%rsp)
movl 0x20(%r12), %eax
movq %rax, 0x88(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x78(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x70(%rsp)
movslq 0x24(%r12), %rax
movq %rax, 0x80(%rsp)
movslq %r13d, %rax
movq %rax, 0x68(%rsp)
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
movq %rbx, %r15
shlq $0x4, %r15
movq %rbx, %r12
shlq $0x7, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x4c(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x9c(%rsp)
movsd 0xb0(%rsp), %xmm0
movsd %xmm1, 0xa0(%rsp)
mulsd %xmm1, %xmm0
addsd 0x90(%rsp), %xmm0
movq 0x88(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x80(%rsp), %rax
movq 0xc0(%rsp), %rcx
movswl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movapd %xmm1, 0xd0(%rsp)
movq 0x229ed0(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%rbp,%r15), %xmm2
unpcklpd 0xd0(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movhpd 0x98(%rax,%r12), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x2405d2
movsd 0xa0(%rsp), %xmm1
addsd 0x144b34(%rip), %xmm1 # 0x3850f8
incl %r13d
cmpl %r13d, %r14d
jne 0x2404bb
jmp 0x24063c
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x2405b3
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x2405b3
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2405b3
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movss 0x78(%rsp), %xmm0
movl 0x4c(%rsp), %edx
movl 0x3c(%rsp), %ecx
movl 0x9c(%rsp), %r8d
movl 0x38(%rsp), %r9d
movss 0x70(%rsp), %xmm1
movq 0x68(%rsp), %rax
movq 0x22d86d(%rip), %r10 # 0x46dea0
callq *(%r10,%rax,8)
jmp 0x2405b3
movq 0x229dad(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStemsEx<ImPlot::GetterYs<unsigned short>, ImPlot::GetterYRef>(char const*, ImPlot::GetterYs<unsigned short> const&, ImPlot::GetterYRef const&)
|
inline void PlotStemsEx(const char* label_id, const GetterM& get_mark, const GetterB& get_base) {
if (BeginItem(label_id, ImPlotCol_Line)) {
if (FitThisFrame()) {
for (int i = 0; i < get_base.Count; ++i) {
FitPoint(get_mark(i));
FitPoint(get_base(i));
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
// render stems
if (s.RenderLine) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderLineSegments(get_mark, get_base, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLin: RenderLineSegments(get_mark, get_base, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LinLog: RenderLineSegments(get_mark, get_base, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLog: RenderLineSegments(get_mark, get_base, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
}
}
// render markers
ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
if (marker != ImPlotMarker_None) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderMarkers(get_mark, TransformerLinLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLin: RenderMarkers(get_mark, TransformerLogLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LinLog: RenderMarkers(get_mark, TransformerLinLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLog: RenderMarkers(get_mark, TransformerLogLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
}
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rsi, %r12
xorl %esi, %esi
callq 0xebca0
testb %al, %al
je 0x241013
movq 0x229cf3(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
cmpb $0x1, 0x218(%rbp)
jne 0x2407c7
cmpl $0x0, 0x8(%r14)
jle 0x2407c7
xorl %ebp, %ebp
leaq 0x50(%rsp), %rbx
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd %xmm1, 0x60(%rsp)
movsd 0x10(%r12), %xmm0
mulsd %xmm1, %xmm0
addsd 0x18(%r12), %xmm0
movq (%r12), %rcx
movl 0x8(%r12), %esi
movslq 0x24(%r12), %rdi
movl 0x20(%r12), %eax
addl %ebp, %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movzwl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm0, 0x50(%rsp)
movsd %xmm1, 0x58(%rsp)
movq %rbx, %rdi
callq 0xe2280
movsd 0x60(%rsp), %xmm0
mulsd 0x10(%r14), %xmm0
addsd 0x18(%r14), %xmm0
movapd %xmm0, %xmm1
movsd (%r14), %xmm0
movsd %xmm1, 0x50(%rsp)
movsd %xmm0, 0x58(%rsp)
movq %rbx, %rdi
callq 0xe2280
incl %ebp
cmpl 0x8(%r14), %ebp
jl 0x24071f
movq 0x229c2c(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
callq 0xe6e40
movq %rax, 0x40(%rsp)
cmpb $0x1, 0x5ec(%rbp)
jne 0x2408ae
leaq 0x578(%rbp), %rdi
callq 0xe7f80
movq 0x229bff(%rip), %rcx # 0x46a3f0
movq (%rcx), %rdx
movq 0x28(%rdx), %rcx
movslq 0x288(%rcx), %rcx
movl 0x158(%rdx,%rcx,4), %edx
cmpq $0x3, %rdx
ja 0x2408ae
leaq 0x169861(%rip), %rsi # 0x3aa078
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xeb090
jmp 0x2408ae
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xe0380
jmp 0x2408ae
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xead80
jmp 0x2408ae
leaq 0x50(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x40(%rsp), %rcx
movl %eax, %r8d
callq 0xe8260
movl 0x5cc(%rbp), %eax
xorl %r13d, %r13d
cmpl $-0x1, %eax
cmovnel %eax, %r13d
leaq 0x598(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x3c(%rsp)
leaq 0x5a8(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x38(%rsp)
movq 0x229b0b(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
movq 0x28(%rcx), %rax
movslq 0x288(%rax), %rbx
movq %rcx, 0x60(%rsp)
movl 0x158(%rcx,%rbx,4), %eax
cmpq $0x3, %rax
ja 0x240fe8
leaq 0x169778(%rip), %rcx # 0x3aa088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x240fe8
movq (%r12), %rsi
movsd 0x10(%r12), %xmm3
movsd 0x18(%r12), %xmm4
movl 0x20(%r12), %edi
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x90(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x88(%rsp)
movslq 0x24(%r12), %r8
movslq %r13d, %rax
movq %rax, 0x78(%rsp)
xorl %r13d, %r13d
xorpd %xmm5, %xmm5
movq %rbx, %r15
shlq $0x4, %r15
movq %rbx, %r12
shlq $0x7, %r12
movsd 0x14476e(%rip), %xmm6 # 0x3850f8
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x70(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x68(%rsp)
movq 0x60(%rsp), %rcx
movsd %xmm3, 0xd0(%rsp)
movsd %xmm4, 0xc0(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0x80(%rsp)
movapd %xmm3, %xmm0
mulsd %xmm5, %xmm0
addsd %xmm4, %xmm0
leal (%rdi,%r13), %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq %r8, %rax
movzwl (%rsi,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movq 0x28(%rcx), %rax
cvtps2pd 0x164(%rcx,%r15), %xmm1
movsd 0x18(%rax), %xmm2
movhpd 0x98(%rax,%r12), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm0
movsd 0x198(%rcx), %xmm2
movhpd 0x1a0(%rcx,%rbx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x240a63
addsd %xmm6, %xmm5
incl %r13d
cmpl %r13d, %r14d
jne 0x2409c7
jmp 0x240fe8
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x240a4e
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x240a4e
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x240a4e
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movss 0x90(%rsp), %xmm0
movl 0x70(%rsp), %edx
movl 0x3c(%rsp), %ecx
movq %r8, %rbp
movl 0x68(%rsp), %r8d
movl 0x38(%rsp), %r9d
movss 0x88(%rsp), %xmm1
movq 0x78(%rsp), %rax
movsd %xmm5, 0xa0(%rsp)
movq 0x22e29d(%rip), %r10 # 0x46ed70
callq *(%r10,%rax,8)
movsd 0x144619(%rip), %xmm6 # 0x3850f8
movsd 0xa0(%rsp), %xmm5
movq %rbp, %r8
movq 0xb0(%rsp), %rdi
movsd 0xc0(%rsp), %xmm4
movsd 0xd0(%rsp), %xmm3
movq 0x80(%rsp), %rsi
movq 0x2298dc(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
jmp 0x240a4e
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x240fe8
movq (%r12), %rax
movq %rax, 0xd0(%rsp)
movups 0x10(%r12), %xmm0
movaps %xmm0, 0xc0(%rsp)
movups 0x18(%r12), %xmm0
movaps %xmm0, 0xb0(%rsp)
movl 0x20(%r12), %eax
movq %rax, 0x90(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x80(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x78(%rsp)
movslq 0x24(%r12), %rax
movq %rax, 0x88(%rsp)
movslq %r13d, %rax
movq %rax, 0x70(%rsp)
xorl %r13d, %r13d
xorpd %xmm4, %xmm4
movq %rbx, %r15
shlq $0x7, %r15
movq %rbx, %r12
shlq $0x4, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x68(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x4c(%rsp)
movapd %xmm4, 0xa0(%rsp)
movq 0x90(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x88(%rsp), %rax
movq 0xd0(%rsp), %rcx
movzwl (%rcx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x2297ec(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x98(%rax,%r15), %xmm0
callq 0xe2ca0
movaps 0xa0(%rsp), %xmm4
divsd 0x1c0(%rbp,%rbx,8), %xmm0
movq 0x28(%rbp), %rax
movsd 0x98(%rax,%r15), %xmm1
cvtsd2ss %xmm0, %xmm0
movsd 0xa0(%rax,%r15), %xmm2
subsd %xmm1, %xmm2
movapd 0xc0(%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtss2sd %xmm0, %xmm0
movaps %xmm4, %xmm2
movlhps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm3, %xmm2
movapd 0xb0(%rsp), %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
cvtps2pd 0x164(%rbp,%r12), %xmm3
addpd %xmm2, %xmm0
movsd 0x18(%rax), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm0
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x240cdb
addsd 0x14442e(%rip), %xmm4 # 0x3850f8
incl %r13d
cmpl %r13d, %r14d
jne 0x240bbe
jmp 0x240fe8
movsd 0x2bc(%rax), %xmm1
movaps %xmm1, %xmm2
shufps $0xe1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[2,3]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
ucomiss %xmm0, %xmm1
seta %cl
cmpleps %xmm0, %xmm2
pextrw $0x2, %xmm2, %edx
testb $0x1, %dl
je 0x240cc2
testb %cl, %cl
je 0x240cc2
movss 0x2c4(%rax), %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm0, %xmm1
jbe 0x240cc2
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movss 0x80(%rsp), %xmm0
movl 0x68(%rsp), %edx
movl 0x3c(%rsp), %ecx
movl 0x4c(%rsp), %r8d
movl 0x38(%rsp), %r9d
movss 0x78(%rsp), %xmm1
movq 0x70(%rsp), %rax
movq 0x22e562(%rip), %r10 # 0x46f2b0
callq *(%r10,%rax,8)
movaps 0xa0(%rsp), %xmm4
jmp 0x240cc2
movzbl 0x5ee(%rbp), %ecx
movss 0x5d0(%rbp), %xmm0
movss 0x5d4(%rbp), %xmm1
movzbl 0x5ef(%rbp), %r9d
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movupd (%r12), %xmm2
movupd 0x10(%r12), %xmm3
movupd %xmm3, 0x10(%rsp)
movupd %xmm2, (%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x28(%rsp)
movl %ebx, %edi
movq 0x40(%rsp), %rsi
movl %r13d, %edx
movl 0x3c(%rsp), %r8d
callq 0xe2ef0
jmp 0x240fe8
movl 0x8(%r12), %r14d
testl %r14d, %r14d
jle 0x240fe8
movq (%r12), %rax
movq %rax, 0xc0(%rsp)
movsd 0x10(%r12), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0x18(%r12), %xmm0
movsd %xmm0, 0x90(%rsp)
movl 0x20(%r12), %eax
movq %rax, 0x88(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x78(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x70(%rsp)
movslq 0x24(%r12), %rax
movq %rax, 0x80(%rsp)
movslq %r13d, %rax
movq %rax, 0x68(%rsp)
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
movq %rbx, %r15
shlq $0x4, %r15
movq %rbx, %r12
shlq $0x7, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x4c(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x9c(%rsp)
movsd 0xb0(%rsp), %xmm0
movsd %xmm1, 0xa0(%rsp)
mulsd %xmm1, %xmm0
addsd 0x90(%rsp), %xmm0
movq 0x88(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x80(%rsp), %rax
movq 0xc0(%rsp), %rcx
movzwl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movapd %xmm1, 0xd0(%rsp)
movq 0x229524(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%rbp,%r15), %xmm2
unpcklpd 0xd0(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movhpd 0x98(%rax,%r12), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x240f7e
movsd 0xa0(%rsp), %xmm1
addsd 0x144188(%rip), %xmm1 # 0x3850f8
incl %r13d
cmpl %r13d, %r14d
jne 0x240e67
jmp 0x240fe8
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x240f5f
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x240f5f
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x240f5f
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movss 0x78(%rsp), %xmm0
movl 0x4c(%rsp), %edx
movl 0x3c(%rsp), %ecx
movl 0x9c(%rsp), %r8d
movl 0x38(%rsp), %r9d
movss 0x70(%rsp), %xmm1
movq 0x68(%rsp), %rax
movq 0x22fbf1(%rip), %r10 # 0x470bd0
callq *(%r10,%rax,8)
jmp 0x240f5f
movq 0x229401(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStems<unsigned int>(char const*, unsigned int const*, int, double, double, double, int, int)
|
void PlotStems(const char* label_id, const T* values, int count, double y_ref, double xscale, double x0, int offset, int stride) {
GetterYs<T> get_mark(values,count,xscale,x0,offset,stride);
GetterYRef get_base(y_ref,count,xscale,x0);
PlotStemsEx(label_id, get_mark, get_base);
}
|
subq $0x48, %rsp
movl %ecx, %eax
movl %edx, %ecx
movq %rsi, (%rsp)
movl %edx, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x18(%rsp)
testl %edx, %edx
je 0x2419f0
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
jmp 0x2419f2
xorl %edx, %edx
movq %rsp, %rsi
movl %edx, 0x20(%rsi)
movl %r8d, 0x24(%rsi)
leaq 0x28(%rsp), %rdx
movsd %xmm0, (%rdx)
movl %ecx, 0x8(%rdx)
movsd %xmm1, 0x10(%rdx)
movsd %xmm2, 0x18(%rdx)
callq 0xe1eb0
addq $0x48, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStems<unsigned long long>(char const*, unsigned long long const*, int, double, double, double, int, int)
|
void PlotStems(const char* label_id, const T* values, int count, double y_ref, double xscale, double x0, int offset, int stride) {
GetterYs<T> get_mark(values,count,xscale,x0,offset,stride);
GetterYRef get_base(y_ref,count,xscale,x0);
PlotStemsEx(label_id, get_mark, get_base);
}
|
subq $0x48, %rsp
movl %ecx, %eax
movl %edx, %ecx
movq %rsi, (%rsp)
movl %edx, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x18(%rsp)
testl %edx, %edx
je 0x242d40
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
jmp 0x242d42
xorl %edx, %edx
movq %rsp, %rsi
movl %edx, 0x20(%rsi)
movl %r8d, 0x24(%rsi)
leaq 0x28(%rsp), %rdx
movsd %xmm0, (%rdx)
movl %ecx, 0x8(%rdx)
movsd %xmm1, 0x10(%rdx)
movsd %xmm2, 0x18(%rdx)
callq 0xe7cc0
addq $0x48, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStems<signed char>(char const*, signed char const*, signed char const*, int, double, int, int)
|
void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double y_ref, int offset, int stride) {
GetterXsYs<T> get_mark(xs,ys,count,offset,stride);
GetterXsYRef<T> get_base(xs,y_ref,count,offset,stride);
PlotStemsEx(label_id, get_mark, get_base);
}
|
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
testl %ecx, %ecx
je 0x244a82
movl %r8d, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
jmp 0x244a84
xorl %edx, %edx
leaq 0x8(%rsp), %rax
movl %edx, 0x14(%rax)
movl %r9d, 0x18(%rax)
leaq 0x28(%rsp), %r8
movq %rsi, (%r8)
movsd %xmm0, 0x8(%r8)
movl %ecx, 0x10(%r8)
movl %edx, 0x14(%r8)
movl %r9d, 0x18(%r8)
movq %rax, %rsi
movq %r8, %rdx
callq 0xe09d0
addq $0x48, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStems<short>(char const*, short const*, short const*, int, double, int, int)
|
void PlotStems(const char* label_id, const T* xs, const T* ys, int count, double y_ref, int offset, int stride) {
GetterXsYs<T> get_mark(xs,ys,count,offset,stride);
GetterXsYRef<T> get_base(xs,y_ref,count,offset,stride);
PlotStemsEx(label_id, get_mark, get_base);
}
|
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
testl %ecx, %ecx
je 0x245c10
movl %r8d, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
jmp 0x245c12
xorl %edx, %edx
leaq 0x8(%rsp), %rax
movl %edx, 0x14(%rax)
movl %r9d, 0x18(%rax)
leaq 0x28(%rsp), %r8
movq %rsi, (%r8)
movsd %xmm0, 0x8(%r8)
movl %ecx, 0x10(%r8)
movl %edx, 0x14(%r8)
movl %r9d, 0x18(%r8)
movq %rax, %rsi
movq %r8, %rdx
callq 0xe36e0
addq $0x48, %rsp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStemsEx<ImPlot::GetterXsYs<int>, ImPlot::GetterXsYRef<int>>(char const*, ImPlot::GetterXsYs<int> const&, ImPlot::GetterXsYRef<int> const&)
|
inline void PlotStemsEx(const char* label_id, const GetterM& get_mark, const GetterB& get_base) {
if (BeginItem(label_id, ImPlotCol_Line)) {
if (FitThisFrame()) {
for (int i = 0; i < get_base.Count; ++i) {
FitPoint(get_mark(i));
FitPoint(get_base(i));
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
// render stems
if (s.RenderLine) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderLineSegments(get_mark, get_base, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLin: RenderLineSegments(get_mark, get_base, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LinLog: RenderLineSegments(get_mark, get_base, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLog: RenderLineSegments(get_mark, get_base, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
}
}
// render markers
ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
if (marker != ImPlotMarker_None) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderMarkers(get_mark, TransformerLinLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLin: RenderMarkers(get_mark, TransformerLogLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LinLog: RenderMarkers(get_mark, TransformerLinLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLog: RenderMarkers(get_mark, TransformerLogLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
}
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r12
xorl %esi, %esi
callq 0xebca0
testb %al, %al
je 0x247657
movq 0x22359d(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
cmpb $0x1, 0x218(%rbp)
jne 0x246f1c
cmpl $0x0, 0x10(%r14)
jle 0x246f1c
xorl %ebp, %ebp
leaq 0x48(%rsp), %rbx
movl 0x10(%r12), %ecx
movslq 0x18(%r12), %rsi
movl 0x14(%r12), %eax
addl %ebp, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%r12), %rcx
movq 0x8(%r12), %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx,%rax), %xmm1
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x50(%rsp)
movq %rbx, %rdi
callq 0xe2280
movq (%r14), %rcx
movl 0x10(%r14), %esi
movslq 0x18(%r14), %rdi
movl 0x14(%r14), %eax
addl %ebp, %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax), %xmm0
movsd 0x8(%r14), %xmm1
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x50(%rsp)
movq %rbx, %rdi
callq 0xe2280
incl %ebp
cmpl 0x10(%r14), %ebp
jl 0x246e75
movq 0x2234d7(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
callq 0xe6e40
movq %rax, 0x38(%rsp)
cmpb $0x1, 0x5ec(%rbp)
jne 0x247003
leaq 0x578(%rbp), %rdi
callq 0xe7f80
movq 0x2234aa(%rip), %rcx # 0x46a3f0
movq (%rcx), %rdx
movq 0x28(%rdx), %rcx
movslq 0x288(%rcx), %rcx
movl 0x158(%rdx,%rcx,4), %edx
cmpq $0x3, %rdx
ja 0x247003
leaq 0x16326c(%rip), %rsi # 0x3aa1d8
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xeb9e0
jmp 0x247003
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xe1580
jmp 0x247003
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xec190
jmp 0x247003
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xe3910
movl 0x5cc(%rbp), %eax
xorl %r13d, %r13d
cmpl $-0x1, %eax
cmovnel %eax, %r13d
leaq 0x598(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x34(%rsp)
leaq 0x5a8(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x30(%rsp)
movq 0x2233b6(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
movq 0x28(%rcx), %rax
movslq 0x288(%rax), %rbx
movq %rcx, 0x88(%rsp)
movl 0x158(%rcx,%rbx,4), %eax
cmpq $0x3, %rax
ja 0x24762c
leaq 0x163180(%rip), %rcx # 0x3aa1e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x10(%r12), %r14d
testl %r14d, %r14d
jle 0x24762c
movq (%r12), %rsi
movq 0x8(%r12), %rdi
movl 0x14(%r12), %r8d
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x78(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x70(%rsp)
movslq 0x18(%r12), %r15
movslq %r13d, %rax
movq %rax, 0x68(%rsp)
xorl %r13d, %r13d
movq %rbx, %r12
shlq $0x4, %r12
movq %rbx, %r11
shlq $0x7, %r11
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x2c(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x58(%rsp)
movq 0x88(%rsp), %rcx
movq %rdi, 0x90(%rsp)
movq %rsi, 0x80(%rsp)
movq %r8, 0x60(%rsp)
leal (%r8,%r13), %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq %r15, %rax
movq 0x28(%rcx), %rdx
movss (%rdi,%rax), %xmm0
movss (%rsi,%rax), %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2pd %xmm1, %xmm0
cvtps2pd 0x164(%rcx,%r12), %xmm1
movsd 0x18(%rdx), %xmm2
movhpd 0x98(%rdx,%r11), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm0
movsd 0x198(%rcx), %xmm2
movhpd 0x1a0(%rcx,%rbx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x24718b
incl %r13d
cmpl %r13d, %r14d
jne 0x2470fa
jmp 0x24762c
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x24717a
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x24717a
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x24717a
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movss 0x78(%rsp), %xmm0
movl 0x2c(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x58(%rsp), %r8d
movl 0x30(%rsp), %r9d
movss 0x70(%rsp), %xmm1
movq 0x68(%rsp), %rax
movq %r11, %rbp
movq 0x227e8c(%rip), %r10 # 0x46f078
callq *(%r10,%rax,8)
movq %rbp, %r11
movq 0x60(%rsp), %r8
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x2231e1(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
jmp 0x24717a
movl 0x10(%r12), %r14d
testl %r14d, %r14d
jle 0x24762c
movq (%r12), %rax
movq %rax, 0x80(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x78(%rsp)
movl 0x14(%r12), %eax
movq %rax, 0x70(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x2c(%rsp)
movslq 0x18(%r12), %rax
movq %rax, 0x68(%rsp)
movslq %r13d, %rax
movq %rax, 0x58(%rsp)
xorl %r13d, %r13d
movq %rbx, %r15
shlq $0x7, %r15
movq %rbx, %r12
shlq $0x4, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x44(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x40(%rsp)
movq 0x70(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x68(%rsp), %rax
movq 0x80(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax), %xmm0
movapd %xmm0, 0x90(%rsp)
movq 0x78(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax), %xmm0
movq 0x22310c(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x98(%rax,%r15), %xmm0
callq 0xe2ca0
divsd 0x1c0(%rbp,%rbx,8), %xmm0
movq 0x28(%rbp), %rax
movsd 0x98(%rax,%r15), %xmm1
movsd 0xa0(%rax,%r15), %xmm2
cvtsd2ss %xmm0, %xmm0
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%rbp,%r12), %xmm2
movapd 0x90(%rsp), %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
movsd 0x18(%rax), %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
subpd %xmm0, %xmm3
movsd 0x198(%rbp), %xmm0
movhpd 0x1a0(%rbp,%rbx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x24739b
incl %r13d
cmpl %r13d, %r14d
jne 0x24729a
jmp 0x24762c
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x24738a
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x24738a
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x24738a
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movss 0x60(%rsp), %xmm0
movl 0x44(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x40(%rsp), %r8d
movl 0x30(%rsp), %r9d
movss 0x2c(%rsp), %xmm1
movq 0x58(%rsp), %rax
movq 0x225e07(%rip), %r10 # 0x46d200
callq *(%r10,%rax,8)
jmp 0x24738a
movzbl 0x5ee(%rbp), %ecx
movss 0x5d0(%rbp), %xmm0
movss 0x5d4(%rbp), %xmm1
movzbl 0x5ef(%rbp), %r9d
movupd (%r12), %xmm2
movupd 0x10(%r12), %xmm3
movupd %xmm3, 0x10(%rsp)
movupd %xmm2, (%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x20(%rsp)
movl %ebx, %edi
movq 0x38(%rsp), %rsi
movl %r13d, %edx
movl 0x34(%rsp), %r8d
callq 0xea0a0
jmp 0x24762c
movl 0x10(%r12), %r14d
testl %r14d, %r14d
jle 0x24762c
movq (%r12), %rax
movq %rax, 0x80(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x78(%rsp)
movl 0x14(%r12), %eax
movq %rax, 0x70(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x2c(%rsp)
movslq 0x18(%r12), %rax
movq %rax, 0x68(%rsp)
movslq %r13d, %rax
movq %rax, 0x58(%rsp)
xorl %r13d, %r13d
movq %rbx, %r15
shlq $0x4, %r15
movq %rbx, %r12
shlq $0x7, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x44(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x40(%rsp)
movq 0x70(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x68(%rsp), %rax
movq 0x80(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax), %xmm0
movq 0x78(%rsp), %rcx
xorps %xmm1, %xmm1
cvtsi2sdl (%rcx,%rax), %xmm1
movapd %xmm1, 0x90(%rsp)
movq 0x222ecc(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%rbp,%r15), %xmm2
unpcklpd 0x90(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movhpd 0x98(%rax,%r12), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x2475c8
incl %r13d
cmpl %r13d, %r14d
jne 0x2474da
jmp 0x24762c
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x2475ba
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x2475ba
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2475ba
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movss 0x60(%rsp), %xmm0
movl 0x44(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x40(%rsp), %r8d
movl 0x30(%rsp), %r9d
movss 0x2c(%rsp), %xmm1
movq 0x58(%rsp), %rax
movq 0x227e62(%rip), %r10 # 0x46f488
callq *(%r10,%rax,8)
jmp 0x2475ba
movq 0x222dbd(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotStemsEx<ImPlot::GetterXsYs<long long>, ImPlot::GetterXsYRef<long long>>(char const*, ImPlot::GetterXsYs<long long> const&, ImPlot::GetterXsYRef<long long> const&)
|
inline void PlotStemsEx(const char* label_id, const GetterM& get_mark, const GetterB& get_base) {
if (BeginItem(label_id, ImPlotCol_Line)) {
if (FitThisFrame()) {
for (int i = 0; i < get_base.Count; ++i) {
FitPoint(get_mark(i));
FitPoint(get_base(i));
}
}
const ImPlotNextItemData& s = GetItemData();
ImDrawList& DrawList = *GetPlotDrawList();
// render stems
if (s.RenderLine) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_Line]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderLineSegments(get_mark, get_base, TransformerLinLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLin: RenderLineSegments(get_mark, get_base, TransformerLogLin(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LinLog: RenderLineSegments(get_mark, get_base, TransformerLinLog(), DrawList, s.LineWeight, col_line); break;
case ImPlotScale_LogLog: RenderLineSegments(get_mark, get_base, TransformerLogLog(), DrawList, s.LineWeight, col_line); break;
}
}
// render markers
ImPlotMarker marker = s.Marker == ImPlotMarker_None ? ImPlotMarker_Circle : s.Marker;
if (marker != ImPlotMarker_None) {
const ImU32 col_line = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerOutline]);
const ImU32 col_fill = ImGui::GetColorU32(s.Colors[ImPlotCol_MarkerFill]);
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderMarkers(get_mark, TransformerLinLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLin: RenderMarkers(get_mark, TransformerLogLin(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LinLog: RenderMarkers(get_mark, TransformerLinLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
case ImPlotScale_LogLog: RenderMarkers(get_mark, TransformerLogLog(), DrawList, marker, s.MarkerSize, s.RenderMarkerLine, col_line, s.MarkerWeight, s.RenderMarkerFill, col_fill); break;
}
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r12
xorl %esi, %esi
callq 0xebca0
testb %al, %al
je 0x2487cb
movq 0x222435(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
cmpb $0x1, 0x218(%rbp)
jne 0x248087
cmpl $0x0, 0x10(%r14)
jle 0x248087
xorl %ebp, %ebp
leaq 0x48(%rsp), %rbx
movl 0x10(%r12), %ecx
movslq 0x18(%r12), %rsi
movl 0x14(%r12), %eax
addl %ebp, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%r12), %rcx
movq 0x8(%r12), %rdx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq (%rdx,%rax), %xmm1
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x50(%rsp)
movq %rbx, %rdi
callq 0xe2280
movq (%r14), %rcx
movl 0x10(%r14), %esi
movslq 0x18(%r14), %rdi
movl 0x14(%r14), %eax
addl %ebp, %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
movsd 0x8(%r14), %xmm1
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x50(%rsp)
movq %rbx, %rdi
callq 0xe2280
incl %ebp
cmpl 0x10(%r14), %ebp
jl 0x247fdd
movq 0x22236c(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
callq 0xe6e40
movq %rax, 0x38(%rsp)
cmpb $0x1, 0x5ec(%rbp)
jne 0x24816e
leaq 0x578(%rbp), %rdi
callq 0xe7f80
movq 0x22233f(%rip), %rcx # 0x46a3f0
movq (%rcx), %rdx
movq 0x28(%rdx), %rcx
movslq 0x288(%rcx), %rcx
movl 0x158(%rdx,%rcx,4), %edx
cmpq $0x3, %rdx
ja 0x24816e
leaq 0x162141(%rip), %rsi # 0x3aa218
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xe1cd0
jmp 0x24816e
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xe8a30
jmp 0x24816e
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xec160
jmp 0x24816e
leaq 0x48(%rsp), %rdx
movl %ecx, (%rdx)
movss 0x5c8(%rbp), %xmm0
movq %r12, %rdi
movq %r14, %rsi
movq 0x38(%rsp), %rcx
movl %eax, %r8d
callq 0xe5d10
movl 0x5cc(%rbp), %eax
xorl %r13d, %r13d
cmpl $-0x1, %eax
cmovnel %eax, %r13d
leaq 0x598(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x34(%rsp)
leaq 0x5a8(%rbp), %rdi
callq 0xe7f80
movl %eax, 0x30(%rsp)
movq 0x22224b(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
movq 0x28(%rcx), %rax
movslq 0x288(%rax), %rbx
movq %rcx, 0x88(%rsp)
movl 0x158(%rcx,%rbx,4), %eax
cmpq $0x3, %rax
ja 0x2487a0
leaq 0x162055(%rip), %rcx # 0x3aa228
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x10(%r12), %r14d
testl %r14d, %r14d
jle 0x2487a0
movq (%r12), %rsi
movq 0x8(%r12), %rdi
movl 0x14(%r12), %r8d
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x78(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x70(%rsp)
movslq 0x18(%r12), %r15
movslq %r13d, %rax
movq %rax, 0x68(%rsp)
xorl %r13d, %r13d
movq %rbx, %r12
shlq $0x4, %r12
movq %rbx, %r11
shlq $0x7, %r11
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x2c(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x58(%rsp)
movq 0x88(%rsp), %rcx
movq %rdi, 0x90(%rsp)
movq %rsi, 0x80(%rsp)
movq %r8, 0x60(%rsp)
leal (%r8,%r13), %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq %r15, %rax
xorps %xmm0, %xmm0
cvtsi2sdq (%rdi,%rax), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq (%rsi,%rax), %xmm1
movq 0x28(%rcx), %rax
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
cvtps2pd 0x164(%rcx,%r12), %xmm0
movsd 0x18(%rax), %xmm2
movhpd 0x98(%rax,%r11), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
movsd 0x198(%rcx), %xmm2
movhpd 0x1a0(%rcx,%rbx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x2482fb
incl %r13d
cmpl %r13d, %r14d
jne 0x248265
jmp 0x2487a0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x2482ea
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x2482ea
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2482ea
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movss 0x78(%rsp), %xmm0
movl 0x2c(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x58(%rsp), %r8d
movl 0x30(%rsp), %r9d
movss 0x70(%rsp), %xmm1
movq 0x68(%rsp), %rax
movq %r11, %rbp
movq 0x222dcc(%rip), %r10 # 0x46b128
callq *(%r10,%rax,8)
movq %rbp, %r11
movq 0x60(%rsp), %r8
movq 0x90(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x222071(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
jmp 0x2482ea
movl 0x10(%r12), %r14d
testl %r14d, %r14d
jle 0x2487a0
movq (%r12), %rax
movq %rax, 0x80(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x78(%rsp)
movl 0x14(%r12), %eax
movq %rax, 0x70(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x2c(%rsp)
movslq 0x18(%r12), %rax
movq %rax, 0x68(%rsp)
movslq %r13d, %rax
movq %rax, 0x58(%rsp)
xorl %r13d, %r13d
movq %rbx, %r15
shlq $0x7, %r15
movq %rbx, %r12
shlq $0x4, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x44(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x40(%rsp)
movq 0x70(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x68(%rsp), %rax
movq 0x80(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
movapd %xmm0, 0x90(%rsp)
movq 0x78(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
movq 0x221f9a(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x98(%rax,%r15), %xmm0
callq 0xe2ca0
divsd 0x1c0(%rbp,%rbx,8), %xmm0
movq 0x28(%rbp), %rax
movsd 0x98(%rax,%r15), %xmm1
movsd 0xa0(%rax,%r15), %xmm2
cvtsd2ss %xmm0, %xmm0
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%rbp,%r12), %xmm2
movapd 0x90(%rsp), %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
movsd 0x18(%rax), %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
subpd %xmm0, %xmm3
movsd 0x198(%rbp), %xmm0
movhpd 0x1a0(%rbp,%rbx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x24850d
incl %r13d
cmpl %r13d, %r14d
jne 0x24840a
jmp 0x2487a0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x2484fc
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x2484fc
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2484fc
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movss 0x60(%rsp), %xmm0
movl 0x44(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x40(%rsp), %r8d
movl 0x30(%rsp), %r9d
movss 0x2c(%rsp), %xmm1
movq 0x58(%rsp), %rax
movq 0x223215(%rip), %r10 # 0x46b780
callq *(%r10,%rax,8)
jmp 0x2484fc
movzbl 0x5ee(%rbp), %ecx
movss 0x5d0(%rbp), %xmm0
movss 0x5d4(%rbp), %xmm1
movzbl 0x5ef(%rbp), %r9d
movupd (%r12), %xmm2
movupd 0x10(%r12), %xmm3
movupd %xmm3, 0x10(%rsp)
movupd %xmm2, (%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x20(%rsp)
movl %ebx, %edi
movq 0x38(%rsp), %rsi
movl %r13d, %edx
movl 0x34(%rsp), %r8d
callq 0xe13b0
jmp 0x2487a0
movl 0x10(%r12), %r14d
testl %r14d, %r14d
jle 0x2487a0
movq (%r12), %rax
movq %rax, 0x80(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x78(%rsp)
movl 0x14(%r12), %eax
movq %rax, 0x70(%rsp)
movss 0x5d0(%rbp), %xmm0
movss %xmm0, 0x60(%rsp)
movss 0x5d4(%rbp), %xmm0
movss %xmm0, 0x2c(%rsp)
movslq 0x18(%r12), %rax
movq %rax, 0x68(%rsp)
movslq %r13d, %rax
movq %rax, 0x58(%rsp)
xorl %r13d, %r13d
movq %rbx, %r15
shlq $0x4, %r15
movq %rbx, %r12
shlq $0x7, %r12
movzbl 0x5ee(%rbp), %eax
movl %eax, 0x44(%rsp)
movzbl 0x5ef(%rbp), %eax
movl %eax, 0x40(%rsp)
movq 0x70(%rsp), %rax
addl %r13d, %eax
cltd
idivl %r14d
leal (%rdx,%r14), %eax
cltd
idivl %r14d
movslq %edx, %rax
imulq 0x68(%rsp), %rax
movq 0x80(%rsp), %rcx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
movq 0x78(%rsp), %rcx
xorps %xmm1, %xmm1
cvtsi2sdq (%rcx,%rax), %xmm1
movapd %xmm1, 0x90(%rsp)
movq 0x221d58(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%rbp,%r15), %xmm2
unpcklpd 0x90(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movhpd 0x98(%rax,%r12), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x48(%rsp)
movq 0x88(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x24873c
incl %r13d
cmpl %r13d, %r14d
jne 0x24864c
jmp 0x2487a0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
ucomiss 0x2bc(%rax), %xmm1
jb 0x24872e
movss 0x2c0(%rax), %xmm2
ucomiss %xmm0, %xmm2
jbe 0x24872e
movss 0x2c4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x24872e
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movss 0x60(%rsp), %xmm0
movl 0x44(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x40(%rsp), %r8d
movl 0x30(%rsp), %r9d
movss 0x2c(%rsp), %xmm1
movq 0x58(%rsp), %rax
movq 0x228716(%rip), %r10 # 0x470eb0
callq *(%r10,%rax,8)
jmp 0x24872e
movq 0x221c49(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotPieChart<unsigned int>(char const* const*, unsigned int const*, int, double, double, double, bool, char const*, double)
|
void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0) {
IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != NULL, "PlotPieChart() needs to be called between BeginPlot() and EndPlot()!");
ImDrawList & DrawList = *GetPlotDrawList();
double sum = 0;
for (int i = 0; i < count; ++i)
sum += (double)values[i];
normalize = normalize || sum > 1.0;
ImPlotPoint center(x,y);
PushPlotClipRect();
double a0 = angle0 * 2 * IM_PI / 360.0;
double a1 = angle0 * 2 * IM_PI / 360.0;
for (int i = 0; i < count; ++i) {
double percent = normalize ? (double)values[i] / sum : (double)values[i];
a1 = a0 + 2 * IM_PI * percent;
if (BeginItem(label_ids[i])) {
ImU32 col = ImGui::GetColorU32(GetCurrentItem()->Color);
if (percent < 0.5) {
RenderPieSlice(DrawList, center, radius, a0, a1, col);
}
else {
RenderPieSlice(DrawList, center, radius, a0, a0 + (a1 - a0) * 0.5, col);
RenderPieSlice(DrawList, center, radius, a0 + (a1 - a0) * 0.5, a1, col);
}
EndItem();
}
a0 = a1;
}
if (fmt != NULL) {
a0 = angle0 * 2 * IM_PI / 360.0;
a1 = angle0 * 2 * IM_PI / 360.0;
char buffer[32];
for (int i = 0; i < count; ++i) {
ImPlotItem* item = GetItem(label_ids[i]);
double percent = normalize ? (double)values[i] / sum : (double)values[i];
a1 = a0 + 2 * IM_PI * percent;
if (item->Show) {
sprintf(buffer, fmt, (double)values[i]);
ImVec2 size = ImGui::CalcTextSize(buffer);
double angle = a0 + (a1 - a0) * 0.5;
ImVec2 pos = PlotToPixels(center.x + 0.5 * radius * cos(angle), center.y + 0.5 * radius * sin(angle));
ImU32 col = CalcTextColor(item->Color);
DrawList.AddText(pos - size * 0.5f, col, buffer);
}
a0 = a1;
}
}
PopPlotClipRect();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movsd %xmm3, 0x38(%rsp)
movq %r8, 0x58(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, (%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdi, 0x88(%rsp)
movq 0x21dbc2(%rip), %rax # 0x46a3f0
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x24cf39
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
callq 0xe6e40
movq %rax, 0x68(%rsp)
movl %r15d, %r12d
xorpd %xmm1, %xmm1
testl %r15d, %r15d
jle 0x24c874
xorl %eax, %eax
movl (%r14,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
addsd %xmm0, %xmm1
incq %rax
cmpq %rax, %r12
jne 0x24c85c
movsd %xmm1, 0x60(%rsp)
ucomisd 0x138876(%rip), %xmm1 # 0x3850f8
seta %bl
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
callq 0xec7f0
testl %r15d, %r15d
jle 0x24cf1c
movl %r15d, 0x74(%rsp)
orb %bl, %bpl
movl %ebp, 0x70(%rsp)
movsd 0x38(%rsp), %xmm0
addsd %xmm0, %xmm0
mulsd 0x15cd68(%rip), %xmm0 # 0x3a9630
movsd 0x60(%rsp), %xmm1
movsd %xmm1, 0x80(%rsp)
jne 0x24c8ea
movsd 0x138817(%rip), %xmm1 # 0x3850f8
movsd %xmm1, 0x80(%rsp)
divsd 0x15cd46(%rip), %xmm0 # 0x3a9638
xorl %r15d, %r15d
movq 0x22332c(%rip), %rbx # 0x46fc28
movsd %xmm0, 0x38(%rsp)
movapd %xmm0, %xmm1
movq %r14, 0x78(%rsp)
movl (%r14,%r15,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
mulsd 0x15cd12(%rip), %xmm0 # 0x3a9640
movsd %xmm1, (%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x88(%rsp), %rax
movq (%rax,%r15,8), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xebca0
testb %al, %al
je 0x24ccd4
movq 0x21da8e(%rip), %rax # 0x46a3f0
movq (%rax), %rax
movq 0x30(%rax), %rdi
addq $0x4, %rdi
callq 0xe7f80
movl %eax, %r13d
movsd 0x15a3eb(%rip), %xmm0 # 0x3a6d68
ucomisd 0x20(%rsp), %xmm0
jbe 0x24ca7d
movq 0x221490(%rip), %rax # 0x46de20
movb (%rax), %al
testb %al, %al
je 0x24cce8
leaq 0x40(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xec980
movlpd %xmm0, (%rbx)
movsd 0x50(%rsp), %xmm2
movsd (%rsp), %xmm1
subsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd 0x15cc80(%rip), %xmm0 # 0x3a9648
cvttsd2si %xmm0, %ebp
cmpl $0x4, %ebp
movl $0x3, %eax
cmovll %eax, %ebp
leal -0x1(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x40(%rsp), %xmm1
movsd %xmm1, 0x20(%rsp)
callq 0xebb60
mulsd 0x8(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0xe1000
mulsd 0x8(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movsd (%rsp), %xmm1
movlpd %xmm0, 0x8(%rbx,%r14,8)
incq %r14
cmpq %r14, %rbp
jne 0x24c9ee
jmp 0x24cc90
movsd 0x50(%rsp), %xmm2
movsd (%rsp), %xmm1
subsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movq 0x221389(%rip), %rax # 0x46de20
movb (%rax), %al
testb %al, %al
je 0x24ccf2
addsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xec980
movsd (%rsp), %xmm1
movlpd %xmm0, (%rbx)
movsd 0x10(%rsp), %xmm2
subsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd 0x15cb6f(%rip), %xmm0 # 0x3a9648
cvttsd2si %xmm0, %ebp
cmpl $0x4, %ebp
movl $0x3, %eax
cmovll %eax, %ebp
leal -0x1(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0x90(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x90(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x40(%rsp), %xmm1
movsd %xmm1, 0x20(%rsp)
callq 0xebb60
mulsd 0x8(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0xe1000
mulsd 0x8(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movsd (%rsp), %xmm1
movlpd %xmm0, 0x8(%rbx,%r14,8)
incq %r14
cmpq %r14, %rbp
jne 0x24cb02
incl %ebp
movq 0x68(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0xe5470
movq 0x221276(%rip), %rax # 0x46de20
movb (%rax), %al
testb %al, %al
je 0x24cd0d
leaq 0x40(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xec980
movlpd %xmm0, (%rbx)
movsd 0x50(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
subsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd 0x15ca65(%rip), %xmm0 # 0x3a9648
cvttsd2si %xmm0, %ebp
cmpl $0x4, %ebp
movl $0x3, %eax
cmovll %eax, %ebp
leal -0x1(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0x30(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x30(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x40(%rsp), %xmm1
movsd %xmm1, (%rsp)
callq 0xebb60
mulsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0xe1000
mulsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movsd 0x10(%rsp), %xmm1
movlpd %xmm0, 0x8(%rbx,%r14,8)
incq %r14
cmpq %r14, %rbp
jne 0x24cc09
incl %ebp
movq 0x68(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0xe5470
movq 0x21d745(%rip), %rax # 0x46a3f0
movq (%rax), %r14
callq 0xec9d0
leaq 0x578(%r14), %rdi
callq 0xec570
movq 0x30(%r14), %rax
movq %rax, 0x38(%r14)
movq $0x0, 0x30(%r14)
movq 0x78(%rsp), %r14
incq %r15
movsd 0x50(%rsp), %xmm1
cmpq %r12, %r15
jne 0x24c90b
jmp 0x24cd17
callq 0xeeb5e
jmp 0x24c99a
movsd %xmm2, 0x10(%rsp)
callq 0xeeafa
movsd 0x10(%rsp), %xmm2
movsd (%rsp), %xmm1
jmp 0x24caa1
callq 0xeeb2c
jmp 0x24cbb4
cmpq $0x0, 0x58(%rsp)
je 0x24cf22
cmpl $0x0, 0x74(%rsp)
jle 0x24cf22
cmpb $0x0, 0x70(%rsp)
jne 0x24cd43
movsd 0x1383bb(%rip), %xmm0 # 0x3850f8
movsd %xmm0, 0x60(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x15a017(%rip), %xmm0 # 0x3a6d68
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movl $0x230, %r13d # imm = 0x230
leaq 0xa0(%rsp), %rbx
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x88(%rsp), %rax
movq (%rax,%r15,8), %rdi
movq 0x21d669(%rip), %rax # 0x46a3f0
movq (%rax), %r14
callq 0xea120
movq 0x28(%r14), %rdi
addq %r13, %rdi
movl %eax, %esi
callq 0xeb870
movq %rax, %rbp
movq 0x78(%rsp), %rax
movl (%rax,%r15,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x60(%rsp), %xmm0
mulsd 0x15c881(%rip), %xmm0 # 0x3a9640
movsd 0x38(%rsp), %xmm1
addsd %xmm1, %xmm0
cmpb $0x1, 0x18(%rbp)
jne 0x24cf0e
movl %eax, %eax
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
movq 0x58(%rsp), %rsi
movb $0x1, %al
callq 0xe0ca0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x126200(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x20(%rsp)
movsd (%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
subsd %xmm2, %xmm1
movsd 0x159f47(%rip), %xmm0 # 0x3a6d68
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x30(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm1, %xmm0
callq 0xebb60
mulsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0xe1000
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rbp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rbp), %xmm2
mulsd 0x159f0b(%rip), %xmm2 # 0x3a6db0
mulsd 0x159f0b(%rip), %xmm1 # 0x3a6db8
addsd %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0xc(%rbp), %xmm2
mulsd 0x159eff(%rip), %xmm2 # 0x3a6dc0
addsd %xmm1, %xmm2
xorl %edx, %edx
ucomisd 0x159e99(%rip), %xmm2 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x20(%rsp), %xmm1
mulps 0x143baa(%rip), %xmm1 # 0x390a90
addps %xmm0, %xmm1
movlps %xmm1, 0x98(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd (%rsp), %xmm0
incq %r15
cmpq %r15, %r12
jne 0x24cd6e
jmp 0x24cf22
cmpq $0x0, 0x58(%rsp)
callq 0xec9d0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15d488(%rip), %rdi # 0x3aa3c8
leaq 0x15d4ec(%rip), %rsi # 0x3aa433
leaq 0x15d7fa(%rip), %rcx # 0x3aa748
movl $0x63c, %edx # imm = 0x63C
callq 0xe3fd0
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotPieChart<double>(char const* const*, double const*, int, double, double, double, bool, char const*, double)
|
void PlotPieChart(const char* const label_ids[], const T* values, int count, double x, double y, double radius, bool normalize, const char* fmt, double angle0) {
IM_ASSERT_USER_ERROR(GImPlot->CurrentPlot != NULL, "PlotPieChart() needs to be called between BeginPlot() and EndPlot()!");
ImDrawList & DrawList = *GetPlotDrawList();
double sum = 0;
for (int i = 0; i < count; ++i)
sum += (double)values[i];
normalize = normalize || sum > 1.0;
ImPlotPoint center(x,y);
PushPlotClipRect();
double a0 = angle0 * 2 * IM_PI / 360.0;
double a1 = angle0 * 2 * IM_PI / 360.0;
for (int i = 0; i < count; ++i) {
double percent = normalize ? (double)values[i] / sum : (double)values[i];
a1 = a0 + 2 * IM_PI * percent;
if (BeginItem(label_ids[i])) {
ImU32 col = ImGui::GetColorU32(GetCurrentItem()->Color);
if (percent < 0.5) {
RenderPieSlice(DrawList, center, radius, a0, a1, col);
}
else {
RenderPieSlice(DrawList, center, radius, a0, a0 + (a1 - a0) * 0.5, col);
RenderPieSlice(DrawList, center, radius, a0 + (a1 - a0) * 0.5, a1, col);
}
EndItem();
}
a0 = a1;
}
if (fmt != NULL) {
a0 = angle0 * 2 * IM_PI / 360.0;
a1 = angle0 * 2 * IM_PI / 360.0;
char buffer[32];
for (int i = 0; i < count; ++i) {
ImPlotItem* item = GetItem(label_ids[i]);
double percent = normalize ? (double)values[i] / sum : (double)values[i];
a1 = a0 + 2 * IM_PI * percent;
if (item->Show) {
sprintf(buffer, fmt, (double)values[i]);
ImVec2 size = ImGui::CalcTextSize(buffer);
double angle = a0 + (a1 - a0) * 0.5;
ImVec2 pos = PlotToPixels(center.x + 0.5 * radius * cos(angle), center.y + 0.5 * radius * sin(angle));
ImU32 col = CalcTextColor(item->Color);
DrawList.AddText(pos - size * 0.5f, col, buffer);
}
a0 = a1;
}
}
PopPlotClipRect();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movsd %xmm3, 0x48(%rsp)
movq %r8, 0x70(%rsp)
movl %ecx, 0x2c(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %rdi, 0x98(%rsp)
movq 0x21bd78(%rip), %rax # 0x46a3f0
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x24ed95
movl %edx, %ebp
movq %rsi, %r14
callq 0xe6e40
movq %rax, 0x78(%rsp)
movl %ebp, %r15d
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x24e6b0
xorl %eax, %eax
addsd (%r14,%rax,8), %xmm0
incq %rax
cmpq %rax, %r15
jne 0x24e6a2
movsd %xmm0, 0x80(%rsp)
ucomisd 0x136a37(%rip), %xmm0 # 0x3850f8
seta %bl
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
callq 0xec7f0
testl %ebp, %ebp
jle 0x24ed78
movl %ebp, 0x8c(%rsp)
movsd 0x48(%rsp), %xmm0
addsd %xmm0, %xmm0
mulsd 0x15af2e(%rip), %xmm0 # 0x3a9630
movl 0x2c(%rsp), %eax
orb %bl, %al
movl %eax, 0x2c(%rsp)
divsd 0x15af24(%rip), %xmm0 # 0x3a9638
movsd %xmm0, 0x48(%rsp)
xorl %ebp, %ebp
movq 0x221505(%rip), %r13 # 0x46fc28
movapd %xmm0, %xmm2
movq %r14, 0x90(%rsp)
movsd 0x80(%rsp), %xmm0
movsd (%r14,%rbp,8), %xmm1
cmpb $0x0, 0x2c(%rsp)
je 0x24e749
divsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rsp)
movapd %xmm1, %xmm0
mulsd 0x15aee5(%rip), %xmm0 # 0x3a9640
movsd %xmm2, 0x8(%rsp)
addsd %xmm2, %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0x98(%rsp), %rax
movq (%rax,%rbp,8), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xebca0
testb %al, %al
je 0x24eb24
movq 0x21bc60(%rip), %rax # 0x46a3f0
movq (%rax), %rax
movq 0x30(%rax), %rdi
addq $0x4, %rdi
callq 0xe7f80
movl %eax, %ebx
movsd 0x1585be(%rip), %xmm0 # 0x3a6d68
ucomisd 0x30(%rsp), %xmm0
jbe 0x24e8b3
movq 0x21f663(%rip), %rax # 0x46de20
movb (%rax), %al
testb %al, %al
je 0x24eb47
leaq 0x58(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xec980
movlpd %xmm0, (%r13)
movsd 0x68(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd 0x15ae50(%rip), %xmm0 # 0x3a9648
cvttsd2si %xmm0, %r12d
cmpl $0x4, %r12d
movl $0x3, %eax
cmovll %eax, %r12d
leal -0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x58(%rsp), %xmm1
movsd %xmm1, 0x30(%rsp)
callq 0xebb60
mulsd 0x10(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0xe1000
mulsd 0x10(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movsd 0x8(%rsp), %xmm1
movlpd %xmm0, 0x8(%r13,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x24e823
jmp 0x24eadc
movsd 0x68(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movq 0x21f552(%rip), %rax # 0x46de20
movb (%rax), %al
testb %al, %al
je 0x24eb51
addsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xec980
movsd 0x8(%rsp), %xmm1
movlpd %xmm0, (%r13)
movsd 0x18(%rsp), %xmm2
subsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd 0x15ad35(%rip), %xmm0 # 0x3a9648
cvttsd2si %xmm0, %r12d
cmpl $0x4, %r12d
movl $0x3, %eax
cmovll %eax, %r12d
leal -0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0xa0(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0xa0(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x58(%rsp), %xmm1
movsd %xmm1, 0x30(%rsp)
callq 0xebb60
mulsd 0x10(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0xe1000
mulsd 0x10(%rsp), %xmm0
movsd 0x50(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movsd 0x8(%rsp), %xmm1
movlpd %xmm0, 0x8(%r13,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x24e941
incl %r12d
movq 0x78(%rsp), %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %ebx, %ecx
callq 0xe5470
movq 0x21f435(%rip), %rax # 0x46de20
movb (%rax), %al
testb %al, %al
je 0x24eb6d
leaq 0x58(%rsp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xec980
movlpd %xmm0, (%r13)
movsd 0x68(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd 0x15ac22(%rip), %xmm0 # 0x3a9648
cvttsd2si %xmm0, %r12d
cmpl $0x4, %r12d
movl $0x3, %eax
cmovll %eax, %r12d
leal -0x1(%r12), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
movsd %xmm2, 0x50(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x50(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x58(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0xebb60
mulsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0xe1000
mulsd 0x10(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
movsd 0x18(%rsp), %xmm1
movlpd %xmm0, 0x8(%r13,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x24ea51
incl %r12d
movq 0x78(%rsp), %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %ebx, %ecx
callq 0xe5470
movq 0x21b8f8(%rip), %rax # 0x46a3f0
movq (%rax), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
movq 0x90(%rsp), %r14
incq %rbp
movsd 0x68(%rsp), %xmm2
cmpq %r15, %rbp
movsd 0x80(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
jne 0x24e738
jmp 0x24eb77
callq 0xeedb6
jmp 0x24e7c7
movsd %xmm2, 0x18(%rsp)
callq 0xeed52
movsd 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
jmp 0x24e8d8
callq 0xeed84
jmp 0x24e9f5
cmpq $0x0, 0x70(%rsp)
je 0x24ed7e
cmpl $0x0, 0x8c(%rsp)
jle 0x24ed7e
movsd 0x10(%rsp), %xmm0
mulsd 0x1581c9(%rip), %xmm0 # 0x3a6d68
movsd %xmm0, 0x10(%rsp)
xorl %ebp, %ebp
movl $0x230, %r13d # imm = 0x230
leaq 0xb0(%rsp), %rbx
movsd %xmm1, 0x48(%rsp)
movq 0x98(%rsp), %rax
movq (%rax,%rbp,8), %rdi
movq 0x21b822(%rip), %rax # 0x46a3f0
movq (%rax), %r14
callq 0xea120
movq 0x28(%r14), %rdi
addq %r13, %rdi
movl %eax, %esi
callq 0xeb870
movq %rax, %r12
movq 0x90(%rsp), %rax
movsd (%rax,%rbp,8), %xmm0
cmpb $0x0, 0x2c(%rsp)
jne 0x24ec01
movapd %xmm0, %xmm2
jmp 0x24ec0e
movapd %xmm0, %xmm2
divsd 0x80(%rsp), %xmm2
movsd 0x48(%rsp), %xmm1
mulsd 0x15aa24(%rip), %xmm2 # 0x3a9640
addsd %xmm1, %xmm2
cmpb $0x1, 0x18(%r12)
jne 0x24ed66
movq %rbx, %rdi
movq 0x70(%rsp), %rsi
movb $0x1, %al
movsd %xmm2, 0x8(%rsp)
callq 0xe0ca0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x1243b0(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x48(%rsp), %xmm2
subsd %xmm2, %xmm1
movsd 0x1580f6(%rip), %xmm0 # 0x3a6d68
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x50(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm1, %xmm0
callq 0xebb60
mulsd 0x10(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x50(%rsp), %xmm0
callq 0xe1000
mulsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0xecad0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%r12), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%r12), %xmm2
mulsd 0x1580b6(%rip), %xmm2 # 0x3a6db0
mulsd 0x1580b6(%rip), %xmm1 # 0x3a6db8
addsd %xmm2, %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0xc(%r12), %xmm2
mulsd 0x1580a8(%rip), %xmm2 # 0x3a6dc0
addsd %xmm1, %xmm2
xorl %edx, %edx
ucomisd 0x158042(%rip), %xmm2 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x30(%rsp), %xmm1
mulps 0x141d53(%rip), %xmm1 # 0x390a90
addps %xmm0, %xmm1
movlps %xmm1, 0xa8(%rsp)
movq 0x78(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x8(%rsp), %xmm2
incq %rbp
movapd %xmm2, %xmm1
cmpq %rbp, %r15
jne 0x24ebb5
jmp 0x24ed7e
cmpq $0x0, 0x70(%rsp)
callq 0xec9d0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15b62c(%rip), %rdi # 0x3aa3c8
leaq 0x15b690(%rip), %rsi # 0x3aa433
leaq 0x15bbb2(%rip), %rcx # 0x3aa95c
movl $0x63c, %edx # imm = 0x63C
callq 0xe3fd0
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<unsigned char, ImPlot::TransformerLinLin>(ImPlot::TransformerLinLin, ImDrawList&, unsigned char const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0xc(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
jle 0x251196
movq %rsi, 0x50(%rsp)
movq 0x148(%rsp), %rcx
movq 0x140(%rsp), %rdx
movd 0x4(%rsp), %xmm3
movl 0xc(%rsp), %eax
movd %eax, %xmm2
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
cvtdq2pd %xmm2, %xmm3
movupd (%rcx), %xmm4
movupd (%rdx), %xmm2
subpd %xmm2, %xmm4
divpd %xmm3, %xmm4
movapd 0x158ae7(%rip), %xmm5 # 0x3a9780
mulpd %xmm4, %xmm5
movq 0x21974c(%rip), %rsi # 0x46a3f0
movq (%rsi), %r8
movslq %edi, %rbx
subsd %xmm0, %xmm1
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2 # xmm2 = xmm2[1],xmm4[1]
movl %eax, %eax
movq %rax, 0x58(%rsp)
xorpd %xmm8, %xmm8
xorl %eax, %eax
movsd 0x15609c(%rip), %xmm3 # 0x3a6d68
movapd %xmm2, 0xc0(%rsp)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x40(%rsp)
movsd 0x156081(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbx, %r15
shlq $0x4, %r15
movq %rbx, %r12
shlq $0x7, %r12
movsd 0x1343f7(%rip), %xmm3 # 0x3850f8
xorpd %xmm7, %xmm7
xorl %ebp, %ebp
movapd %xmm4, 0xd0(%rsp)
movq %r9, 0xa8(%rsp)
movsd %xmm1, 0x68(%rsp)
movsd %xmm0, 0x60(%rsp)
movapd %xmm5, 0x70(%rsp)
movsd %xmm6, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x50(%rsp), %r13
cmpl $0x0, 0xc(%rsp)
jle 0x250f35
movl %ebp, 0x8(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm7, 0x10(%rsp)
mulsd %xmm7, %xmm2
addsd 0x40(%rsp), %xmm2
movsd %xmm2, 0x90(%rsp)
movq %rax, 0x18(%rsp)
cltq
addq 0x48(%rsp), %rax
movq %rax, 0x80(%rsp)
xorpd %xmm7, %xmm7
xorl %r14d, %r14d
movsd %xmm7, 0x30(%rsp)
movsd (%rdx), %xmm2
addsd %xmm6, %xmm2
movapd %xmm7, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm6
movsd 0x8(%rcx), %xmm2
subsd 0x90(%rsp), %xmm2
unpcklpd %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
movq (%rsi), %rax
movq %rcx, %rbp
movq 0x28(%rax), %rcx
movapd %xmm5, %xmm7
addpd %xmm6, %xmm7
subpd %xmm5, %xmm6
cvtps2pd 0x164(%rax,%r15), %xmm2
movsd 0x18(%rcx), %xmm3
movapd %xmm3, %xmm4
movhpd 0x98(%rcx,%r12), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm6
movsd 0x198(%rax), %xmm4
movapd %xmm4, %xmm5
movhpd 0x1a0(%rax,%rbx,8), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd %xmm6, %xmm5
addpd %xmm2, %xmm5
cvtpd2ps %xmm5, %xmm2
movlpd %xmm2, 0x38(%rsp)
cvtps2pd 0x164(%rax,%r15), %xmm2
movhpd 0x98(%rcx,%r12), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm7
movhpd 0x1a0(%rax,%rbx,8), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm7, %xmm4
addpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm2
movlpd %xmm2, 0xb8(%rsp)
movq 0x80(%rsp), %rax
movzbl (%rax,%r14), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
subsd %xmm0, %xmm2
divsd %xmm1, %xmm2
addsd %xmm8, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xe0(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movq 0x20(%rsp), %rax
mulss 0x234(%rax), %xmm1
movss %xmm1, 0xec(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq 0x38(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x30(%rsp), %xmm7
movsd 0x28(%rsp), %xmm6
xorpd %xmm8, %xmm8
movapd 0x70(%rsp), %xmm5
movq %rbp, %rcx
movsd 0x134213(%rip), %xmm3 # 0x3850f8
movq 0x219504(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
addsd %xmm3, %xmm7
incq %r14
cmpl %r14d, 0x58(%rsp)
jne 0x250d86
movq 0x18(%rsp), %rax
addl %r14d, %eax
movq 0xa8(%rsp), %r9
movsd 0x10(%rsp), %xmm7
movl 0x8(%rsp), %ebp
addsd %xmm3, %xmm7
incl %ebp
cmpl 0x4(%rsp), %ebp
jne 0x250d3a
cmpl $0x0, 0x4(%rsp)
setle %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x251196
movsd 0x155e05(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
xorl %ecx, %ecx
xorpd %xmm11, %xmm11
xorl %r8d, %r8d
movsd %xmm5, 0x20(%rsp)
movq %rbx, 0xb0(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x251183
movl %r8d, 0x8(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm11, 0x10(%rsp)
mulsd %xmm11, %xmm2
addsd 0x40(%rsp), %xmm2
movsd %xmm2, 0x70(%rsp)
movl %ecx, 0x18(%rsp)
movslq %ecx, %rax
addq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
xorpd %xmm2, %xmm2
xorl %r13d, %r13d
movsd %xmm2, 0x30(%rsp)
movsd (%rdx), %xmm0
addsd %xmm5, %xmm0
movapd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rdx), %xmm0
addsd %xmm3, %xmm0
subsd 0x70(%rsp), %xmm0
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
cvtps2pd 0x164(%rax,%r15), %xmm0
movsd 0x18(%rcx), %xmm2
movhpd 0x98(%rcx,%r12), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
movsd 0x198(%rax), %xmm2
movhpd 0x1a0(%rax,%rbx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd %xmm0, 0x90(%rsp)
movq 0x28(%rsp), %rbp
movzbl (%rbp,%r13), %edx
leaq 0xe0(%rsp), %rbx
movq %rbx, %rdi
movq %r9, %rsi
xorl %eax, %eax
movq %r9, %r14
callq 0xe0ca0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x121f8c(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x80(%rsp)
movzbl (%rbp,%r13), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subsd 0x60(%rsp), %xmm0
divsd 0x68(%rsp), %xmm0
addsd 0x1585ae(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x155cee(%rip), %xmm0 # 0x3a6db0
mulsd 0x155cee(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x155ce3(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x155c7d(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x80(%rsp), %xmm0
mulps 0x13f98b(%rip), %xmm0 # 0x390a90
addps 0x90(%rsp), %xmm0
movlps %xmm0, 0x38(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x30(%rsp), %xmm2
movq 0xb0(%rsp), %rbx
movsd 0x20(%rsp), %xmm5
movq %r14, %r9
movsd 0x133fb2(%rip), %xmm3 # 0x3850f8
movq 0x2192a3(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
addsd %xmm3, %xmm2
incq %r13
cmpl %r13d, 0x58(%rsp)
jne 0x250fcc
movl 0x18(%rsp), %ecx
addl %r13d, %ecx
movsd 0x10(%rsp), %xmm11
movl 0x8(%rsp), %r8d
addsd %xmm3, %xmm11
incl %r8d
cmpl 0x4(%rsp), %r8d
jne 0x250f83
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<unsigned char, ImPlot::TransformerLogLog>(ImPlot::TransformerLogLog, ImDrawList&, unsigned char const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movl %r8d, 0xc(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
jle 0x25277a
movq %r9, 0xc0(%rsp)
movq 0x1b8(%rsp), %rdx
movq 0x1b0(%rsp), %r8
movsd (%rdx), %xmm4
movsd 0x8(%rdx), %xmm5
subsd (%r8), %xmm4
movl 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm3
subsd 0x8(%r8), %xmm5
cvtsi2sdl 0x8(%rsp), %xmm2
divsd %xmm3, %xmm4
divsd %xmm2, %xmm5
movsd 0x154db0(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm5, %xmm7
mulsd %xmm2, %xmm7
movq 0x218421(%rip), %rcx # 0x46a3f0
movq (%rcx), %r15
movslq %edi, %rbp
subsd %xmm0, %xmm1
movl %eax, %eax
movq %rax, 0xe0(%rsp)
xorl %ecx, %ecx
movsd 0x154d7b(%rip), %xmm6 # 0x3a6d68
movsd %xmm5, 0xb0(%rsp)
mulsd %xmm5, %xmm6
movsd %xmm6, 0xa8(%rsp)
movsd 0x154d5d(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %r13
shlq $0x7, %r13
movq %rbp, %rax
shlq $0x4, %rax
movq %rax, 0xd8(%rsp)
movsd 0x1330cb(%rip), %xmm5 # 0x3850f8
xorpd %xmm8, %xmm8
xorl %eax, %eax
movq %rsi, 0xf0(%rsp)
movsd %xmm4, 0xe8(%rsp)
movsd %xmm3, 0x58(%rsp)
movsd %xmm1, 0xf8(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm6, 0x140(%rsp)
movq %rbp, 0xc8(%rsp)
movq %r15, 0x138(%rsp)
movsd %xmm0, 0xd0(%rsp)
movq 0xc8(%rsp), %rbp
movq 0xd8(%rsp), %rbx
cmpl $0x0, 0xc(%rsp)
jle 0x252448
movl %eax, 0x6c(%rsp)
movsd 0xb0(%rsp), %xmm2
movsd %xmm8, 0x128(%rsp)
mulsd %xmm8, %xmm2
addsd 0xa8(%rsp), %xmm2
movsd %xmm2, 0x50(%rsp)
movq %rcx, 0x130(%rsp)
movslq %ecx, %rax
addq 0xb8(%rsp), %rax
movq %rax, 0x48(%rsp)
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
movsd %xmm2, 0x90(%rsp)
movsd (%r8), %xmm0
addsd %xmm6, %xmm0
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x80(%rsp)
movsd 0x8(%rdx), %xmm1
subsd 0x50(%rsp), %xmm1
movsd %xmm1, 0x30(%rsp)
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
subsd %xmm7, %xmm1
movsd %xmm1, 0x20(%rsp)
movq 0x2182c2(%rip), %r12 # 0x46a3f0
movq (%r12), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x20(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x100(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x110(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0x100(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x110(%rsp), %xmm0
movhpd 0x1c0(%r15,%rbp,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x70(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm3
cvtps2pd %xmm0, %xmm0
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtps2pd 0x164(%r15,%rbx), %xmm2
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x60(%rsp)
movsd 0x80(%rsp), %xmm1
addsd 0x58(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq (%r12), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm1
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x30(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x70(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x80(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0x70(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x20(%rsp), %xmm0
movhpd 0x1c0(%r15,%rbp,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x80(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x30(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
cvtps2pd 0x164(%r15,%rbx), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq 0x138(%rsp), %r15
leaq 0x150(%rsp), %r12
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x148(%rsp)
movq 0x48(%rsp), %rax
movzbl (%rax,%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subsd 0xd0(%rsp), %xmm0
divsd 0xf8(%rsp), %xmm0
addsd 0x1572cf(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x150(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
mulss 0x234(%r15), %xmm1
movss %xmm1, 0x15c(%rsp)
movq %r12, %rdi
leaq 0x60(%rsp), %r12
callq 0xe7f80
xorps %xmm0, %xmm0
movq 0xf0(%rsp), %rdi
movq %r12, %rsi
leaq 0x148(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x90(%rsp), %xmm2
movsd 0x140(%rsp), %xmm6
movsd 0x10(%rsp), %xmm7
movq 0x1b8(%rsp), %rdx
movsd 0x132cf5(%rip), %xmm5 # 0x3850f8
movsd 0x58(%rsp), %xmm3
movsd 0xe8(%rsp), %xmm4
movq 0x1b0(%rsp), %r8
addsd %xmm5, %xmm2
incq %r14
cmpl %r14d, 0xe0(%rsp)
jne 0x2520e1
movq 0x130(%rsp), %rcx
addl %r14d, %ecx
movsd 0x128(%rsp), %xmm8
movl 0x6c(%rsp), %eax
addsd %xmm5, %xmm8
incl %eax
cmpl 0x8(%rsp), %eax
jne 0x25208c
cmpl $0x0, 0x8(%rsp)
setle %al
movq 0xc0(%rsp), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x25277a
leaq 0x150(%rsp), %r15
leaq 0x60(%rsp), %rbx
xorl %edx, %edx
xorpd %xmm10, %xmm10
xorl %esi, %esi
movq 0xc8(%rsp), %rbp
cmpl $0x0, 0xc(%rsp)
jle 0x252769
movl %esi, 0x48(%rsp)
movsd 0xb0(%rsp), %xmm11
movsd %xmm10, 0x50(%rsp)
mulsd %xmm10, %xmm11
addsd 0xa8(%rsp), %xmm11
movsd %xmm11, 0x70(%rsp)
movl %edx, 0x100(%rsp)
movslq %edx, %rdx
addq 0xb8(%rsp), %rdx
movq %rdx, 0x110(%rsp)
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
movsd %xmm2, 0x30(%rsp)
movsd (%r8), %xmm1
addsd %xmm3, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd 0x8(%r8), %xmm1
addsd %xmm5, %xmm1
subsd 0x70(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %rbx, %r12
movq %r15, %rbx
movq 0x217ec6(%rip), %rax # 0x46a3f0
movq (%rax), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x10(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x80(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x80(%rsp), %xmm0
movhpd 0x1c0(%r15,%rbp,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x90(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
movq 0xd8(%rsp), %rcx
cvtps2pd 0x164(%r15,%rcx), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rbx, %r15
movq %r12, %rbx
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x110(%rsp), %r12
movzbl (%r12,%r14), %edx
movq %r15, %rdi
movq 0xc0(%rsp), %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x12099c(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
movzbl (%r12,%r14), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subsd 0xd0(%rsp), %xmm0
divsd 0xf8(%rsp), %xmm0
addsd 0x156fb9(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x1546f9(%rip), %xmm0 # 0x3a6db0
mulsd 0x1546f9(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x1546ee(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x154688(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x13e396(%rip), %xmm0 # 0x390a90
addps 0x10(%rsp), %xmm0
movlps %xmm0, 0x60(%rsp)
movq 0xf0(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x30(%rsp), %xmm2
movsd 0x1329d0(%rip), %xmm5 # 0x3850f8
movsd 0x58(%rsp), %xmm3
movsd 0xe8(%rsp), %xmm4
movq 0x1b0(%rsp), %r8
addsd %xmm5, %xmm2
incq %r14
cmpl %r14d, 0xe0(%rsp)
jne 0x2524ec
movl 0x100(%rsp), %edx
addl %r14d, %edx
movsd 0x50(%rsp), %xmm10
movl 0x48(%rsp), %esi
addsd %xmm5, %xmm10
incl %esi
cmpl 0x8(%rsp), %esi
jne 0x252495
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<short, ImPlot::TransformerLinLin>(ImPlot::TransformerLinLin, ImDrawList&, short const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0x14(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
jle 0x252e90
movq %rsi, 0x58(%rsp)
movq 0x148(%rsp), %r8
movq 0x140(%rsp), %rdx
movd 0xc(%rsp), %xmm3
movl 0x14(%rsp), %eax
movd %eax, %xmm2
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
cvtdq2pd %xmm2, %xmm3
movupd (%r8), %xmm4
movupd (%rdx), %xmm2
subpd %xmm2, %xmm4
divpd %xmm3, %xmm4
movapd 0x156dfa(%rip), %xmm5 # 0x3a9780
mulpd %xmm4, %xmm5
movq 0x217a5f(%rip), %rsi # 0x46a3f0
movq (%rsi), %rcx
movslq %edi, %rbp
subsd %xmm0, %xmm1
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2 # xmm2 = xmm2[1],xmm4[1]
movl %eax, %eax
movq %rax, 0x68(%rsp)
xorpd %xmm8, %xmm8
xorl %eax, %eax
movsd 0x1543af(%rip), %xmm3 # 0x3a6d68
movapd %xmm2, 0xc0(%rsp)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x48(%rsp)
movsd 0x154394(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %rbx
shlq $0x4, %rbx
movq %rbp, %r15
shlq $0x7, %r15
movsd 0x13270a(%rip), %xmm3 # 0x3850f8
xorpd %xmm7, %xmm7
xorl %r14d, %r14d
movapd %xmm4, 0xd0(%rsp)
movq %r9, 0x60(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm0, 0x70(%rsp)
movapd %xmm5, 0x80(%rsp)
movsd %xmm6, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x58(%rsp), %r13
cmpl $0x0, 0x14(%rsp)
jle 0x252c3a
movl %r14d, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm7, 0x18(%rsp)
mulsd %xmm7, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0xa0(%rsp)
movq %rax, 0x20(%rsp)
cltq
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,2), %rax
movq %rax, 0x90(%rsp)
xorpd %xmm7, %xmm7
xorl %r12d, %r12d
movsd %xmm7, 0x38(%rsp)
movsd (%rdx), %xmm2
addsd %xmm6, %xmm2
movapd %xmm7, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm6
movsd 0x8(%r8), %xmm2
subsd 0xa0(%rsp), %xmm2
unpcklpd %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
movapd %xmm5, %xmm7
addpd %xmm6, %xmm7
subpd %xmm5, %xmm6
cvtps2pd 0x164(%rax,%rbx), %xmm2
movsd 0x18(%rcx), %xmm3
movapd %xmm3, %xmm4
movhpd 0x98(%rcx,%r15), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm6
movsd 0x198(%rax), %xmm4
movapd %xmm4, %xmm5
movhpd 0x1a0(%rax,%rbp,8), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd %xmm6, %xmm5
addpd %xmm2, %xmm5
cvtpd2ps %xmm5, %xmm2
movlpd %xmm2, 0x40(%rsp)
cvtps2pd 0x164(%rax,%rbx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm7
movhpd 0x1a0(%rax,%rbp,8), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm7, %xmm4
addpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm2
movlpd %xmm2, 0xb8(%rsp)
movq 0x90(%rsp), %rax
movswl (%rax,%r12,2), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
subsd %xmm0, %xmm2
divsd %xmm1, %xmm2
addsd %xmm8, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movq %r15, %r14
movq %rbx, %r15
movq %rbp, %rbx
movq %r8, %rbp
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xe0(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movq 0x28(%rsp), %rax
mulss 0x234(%rax), %xmm1
movss %xmm1, 0xec(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x38(%rsp), %xmm7
movsd 0x30(%rsp), %xmm6
xorpd %xmm8, %xmm8
movapd 0x80(%rsp), %xmm5
movq %rbp, %r8
movq %rbx, %rbp
movq %r15, %rbx
movq %r14, %r15
movsd 0x13250c(%rip), %xmm3 # 0x3850f8
movq 0x2177fd(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
addsd %xmm3, %xmm7
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x252a79
movq 0x20(%rsp), %rax
addl %r12d, %eax
movq 0x60(%rsp), %r9
movsd 0x18(%rsp), %xmm7
movl 0x10(%rsp), %r14d
addsd %xmm3, %xmm7
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x252a28
cmpl $0x0, 0xc(%rsp)
setle %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x252e90
movsd 0x1540fe(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
xorl %ecx, %ecx
xorpd %xmm11, %xmm11
xorl %edi, %edi
movsd %xmm5, 0x28(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x252e7f
movl %edi, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm11, 0x18(%rsp)
mulsd %xmm11, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0x80(%rsp)
movl %ecx, 0x20(%rsp)
movslq %ecx, %rax
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,2), %rax
movq %rax, 0x30(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0x38(%rsp)
movsd (%rdx), %xmm0
addsd %xmm5, %xmm0
movapd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rdx), %xmm0
addsd %xmm3, %xmm0
subsd 0x80(%rsp), %xmm0
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
cvtps2pd 0x164(%rax,%rbx), %xmm0
movsd 0x18(%rcx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
movsd 0x198(%rax), %xmm2
movhpd 0x1a0(%rax,%rbp,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0x30(%rsp), %r13
movswl (%r13,%r12,2), %edx
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %r9, %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x120289(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
movswl (%r13,%r12,2), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subsd 0x70(%rsp), %xmm0
divsd 0x78(%rsp), %xmm0
addsd 0x1568ab(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x153feb(%rip), %xmm0 # 0x3a6db0
mulsd 0x153feb(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x153fe0(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x153f7a(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x13dc88(%rip), %xmm0 # 0x390a90
addps 0xa0(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x38(%rsp), %xmm2
movsd 0x28(%rsp), %xmm5
movq 0x60(%rsp), %r9
movsd 0x1322b5(%rip), %xmm3 # 0x3850f8
movq 0x2175a6(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
addsd %xmm3, %xmm2
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x252cd0
movl 0x20(%rsp), %ecx
addl %r12d, %ecx
movsd 0x18(%rsp), %xmm11
movl 0x10(%rsp), %edi
addsd %xmm3, %xmm11
incl %edi
cmpl 0xc(%rsp), %edi
jne 0x252c81
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<unsigned short, ImPlot::TransformerLinLin>(ImPlot::TransformerLinLin, ImDrawList&, unsigned short const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0x14(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
jle 0x254b96
movq %rsi, 0x58(%rsp)
movq 0x148(%rsp), %r8
movq 0x140(%rsp), %rdx
movd 0xc(%rsp), %xmm3
movl 0x14(%rsp), %eax
movd %eax, %xmm2
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
cvtdq2pd %xmm2, %xmm3
movupd (%r8), %xmm4
movupd (%rdx), %xmm2
subpd %xmm2, %xmm4
divpd %xmm3, %xmm4
movapd 0x1550f4(%rip), %xmm5 # 0x3a9780
mulpd %xmm4, %xmm5
movq 0x215d59(%rip), %rsi # 0x46a3f0
movq (%rsi), %rcx
movslq %edi, %rbp
subsd %xmm0, %xmm1
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2 # xmm2 = xmm2[1],xmm4[1]
movl %eax, %eax
movq %rax, 0x68(%rsp)
xorpd %xmm8, %xmm8
xorl %eax, %eax
movsd 0x1526a9(%rip), %xmm3 # 0x3a6d68
movapd %xmm2, 0xc0(%rsp)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x48(%rsp)
movsd 0x15268e(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %rbx
shlq $0x4, %rbx
movq %rbp, %r15
shlq $0x7, %r15
movsd 0x130a04(%rip), %xmm3 # 0x3850f8
xorpd %xmm7, %xmm7
xorl %r14d, %r14d
movapd %xmm4, 0xd0(%rsp)
movq %r9, 0x60(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm0, 0x70(%rsp)
movapd %xmm5, 0x80(%rsp)
movsd %xmm6, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x58(%rsp), %r13
cmpl $0x0, 0x14(%rsp)
jle 0x254940
movl %r14d, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm7, 0x18(%rsp)
mulsd %xmm7, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0xa0(%rsp)
movq %rax, 0x20(%rsp)
cltq
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,2), %rax
movq %rax, 0x90(%rsp)
xorpd %xmm7, %xmm7
xorl %r12d, %r12d
movsd %xmm7, 0x38(%rsp)
movsd (%rdx), %xmm2
addsd %xmm6, %xmm2
movapd %xmm7, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm6
movsd 0x8(%r8), %xmm2
subsd 0xa0(%rsp), %xmm2
unpcklpd %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
movapd %xmm5, %xmm7
addpd %xmm6, %xmm7
subpd %xmm5, %xmm6
cvtps2pd 0x164(%rax,%rbx), %xmm2
movsd 0x18(%rcx), %xmm3
movapd %xmm3, %xmm4
movhpd 0x98(%rcx,%r15), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm6
movsd 0x198(%rax), %xmm4
movapd %xmm4, %xmm5
movhpd 0x1a0(%rax,%rbp,8), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd %xmm6, %xmm5
addpd %xmm2, %xmm5
cvtpd2ps %xmm5, %xmm2
movlpd %xmm2, 0x40(%rsp)
cvtps2pd 0x164(%rax,%rbx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm7
movhpd 0x1a0(%rax,%rbp,8), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm7, %xmm4
addpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm2
movlpd %xmm2, 0xb8(%rsp)
movq 0x90(%rsp), %rax
movzwl (%rax,%r12,2), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
subsd %xmm0, %xmm2
divsd %xmm1, %xmm2
addsd %xmm8, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movq %r15, %r14
movq %rbx, %r15
movq %rbp, %rbx
movq %r8, %rbp
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xe0(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movq 0x28(%rsp), %rax
mulss 0x234(%rax), %xmm1
movss %xmm1, 0xec(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x38(%rsp), %xmm7
movsd 0x30(%rsp), %xmm6
xorpd %xmm8, %xmm8
movapd 0x80(%rsp), %xmm5
movq %rbp, %r8
movq %rbx, %rbp
movq %r15, %rbx
movq %r14, %r15
movsd 0x130806(%rip), %xmm3 # 0x3850f8
movq 0x215af7(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
addsd %xmm3, %xmm7
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x25477f
movq 0x20(%rsp), %rax
addl %r12d, %eax
movq 0x60(%rsp), %r9
movsd 0x18(%rsp), %xmm7
movl 0x10(%rsp), %r14d
addsd %xmm3, %xmm7
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x25472e
cmpl $0x0, 0xc(%rsp)
setle %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x254b96
movsd 0x1523f8(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
xorl %ecx, %ecx
xorpd %xmm11, %xmm11
xorl %edi, %edi
movsd %xmm5, 0x28(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x254b85
movl %edi, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm11, 0x18(%rsp)
mulsd %xmm11, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0x80(%rsp)
movl %ecx, 0x20(%rsp)
movslq %ecx, %rax
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,2), %rax
movq %rax, 0x30(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0x38(%rsp)
movsd (%rdx), %xmm0
addsd %xmm5, %xmm0
movapd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rdx), %xmm0
addsd %xmm3, %xmm0
subsd 0x80(%rsp), %xmm0
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
cvtps2pd 0x164(%rax,%rbx), %xmm0
movsd 0x18(%rcx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
movsd 0x198(%rax), %xmm2
movhpd 0x1a0(%rax,%rbp,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0x30(%rsp), %r13
movzwl (%r13,%r12,2), %edx
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %r9, %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x11e583(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
movzwl (%r13,%r12,2), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subsd 0x70(%rsp), %xmm0
divsd 0x78(%rsp), %xmm0
addsd 0x154ba5(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x1522e5(%rip), %xmm0 # 0x3a6db0
mulsd 0x1522e5(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x1522da(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x152274(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x13bf82(%rip), %xmm0 # 0x390a90
addps 0xa0(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x38(%rsp), %xmm2
movsd 0x28(%rsp), %xmm5
movq 0x60(%rsp), %r9
movsd 0x1305af(%rip), %xmm3 # 0x3850f8
movq 0x2158a0(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
addsd %xmm3, %xmm2
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x2549d6
movl 0x20(%rsp), %ecx
addl %r12d, %ecx
movsd 0x18(%rsp), %xmm11
movl 0x10(%rsp), %edi
addsd %xmm3, %xmm11
incl %edi
cmpl 0xc(%rsp), %edi
jne 0x254987
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<int, ImPlot::TransformerLinLin>(ImPlot::TransformerLinLin, ImDrawList&, int const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0x14(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
jle 0x256895
movq %rsi, 0x58(%rsp)
movq 0x148(%rsp), %r8
movq 0x140(%rsp), %rdx
movd 0xc(%rsp), %xmm3
movl 0x14(%rsp), %eax
movd %eax, %xmm2
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
cvtdq2pd %xmm2, %xmm3
movupd (%r8), %xmm4
movupd (%rdx), %xmm2
subpd %xmm2, %xmm4
divpd %xmm3, %xmm4
movapd 0x1533ee(%rip), %xmm5 # 0x3a9780
mulpd %xmm4, %xmm5
movq 0x214053(%rip), %rsi # 0x46a3f0
movq (%rsi), %rcx
movslq %edi, %rbp
subsd %xmm0, %xmm1
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2 # xmm2 = xmm2[1],xmm4[1]
movl %eax, %eax
movq %rax, 0x68(%rsp)
xorpd %xmm8, %xmm8
xorl %eax, %eax
movsd 0x1509a3(%rip), %xmm3 # 0x3a6d68
movapd %xmm2, 0xc0(%rsp)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x48(%rsp)
movsd 0x150988(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %rbx
shlq $0x4, %rbx
movq %rbp, %r15
shlq $0x7, %r15
movsd 0x12ecfe(%rip), %xmm3 # 0x3850f8
xorpd %xmm7, %xmm7
xorl %r14d, %r14d
movapd %xmm4, 0xd0(%rsp)
movq %r9, 0x60(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm0, 0x70(%rsp)
movapd %xmm5, 0x80(%rsp)
movsd %xmm6, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x58(%rsp), %r13
cmpl $0x0, 0x14(%rsp)
jle 0x256643
movl %r14d, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm7, 0x18(%rsp)
mulsd %xmm7, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0xa0(%rsp)
movq %rax, 0x20(%rsp)
cltq
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x90(%rsp)
xorpd %xmm7, %xmm7
xorl %r12d, %r12d
movsd %xmm7, 0x38(%rsp)
movsd (%rdx), %xmm2
addsd %xmm6, %xmm2
movapd %xmm7, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm6
movsd 0x8(%r8), %xmm2
subsd 0xa0(%rsp), %xmm2
unpcklpd %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
movapd %xmm5, %xmm7
addpd %xmm6, %xmm7
subpd %xmm5, %xmm6
cvtps2pd 0x164(%rax,%rbx), %xmm2
movsd 0x18(%rcx), %xmm3
movapd %xmm3, %xmm4
movhpd 0x98(%rcx,%r15), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm6
movsd 0x198(%rax), %xmm4
movapd %xmm4, %xmm5
movhpd 0x1a0(%rax,%rbp,8), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd %xmm6, %xmm5
addpd %xmm2, %xmm5
cvtpd2ps %xmm5, %xmm2
movlpd %xmm2, 0x40(%rsp)
cvtps2pd 0x164(%rax,%rbx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm7
movhpd 0x1a0(%rax,%rbp,8), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm7, %xmm4
addpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm2
movlpd %xmm2, 0xb8(%rsp)
movq 0x90(%rsp), %rax
xorps %xmm2, %xmm2
cvtsi2sdl (%rax,%r12,4), %xmm2
subsd %xmm0, %xmm2
divsd %xmm1, %xmm2
addsd %xmm8, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movq %r15, %r14
movq %rbx, %r15
movq %rbp, %rbx
movq %r8, %rbp
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xe0(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movq 0x28(%rsp), %rax
mulss 0x234(%rax), %xmm1
movss %xmm1, 0xec(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x38(%rsp), %xmm7
movsd 0x30(%rsp), %xmm6
xorpd %xmm8, %xmm8
movapd 0x80(%rsp), %xmm5
movq %rbp, %r8
movq %rbx, %rbp
movq %r15, %rbx
movq %r14, %r15
movsd 0x12eb03(%rip), %xmm3 # 0x3850f8
movq 0x213df4(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
addsd %xmm3, %xmm7
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x256485
movq 0x20(%rsp), %rax
addl %r12d, %eax
movq 0x60(%rsp), %r9
movsd 0x18(%rsp), %xmm7
movl 0x10(%rsp), %r14d
addsd %xmm3, %xmm7
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x256434
cmpl $0x0, 0xc(%rsp)
setle %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x256895
movsd 0x1506f5(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
xorl %ecx, %ecx
xorpd %xmm11, %xmm11
xorl %edi, %edi
movsd %xmm5, 0x28(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x256884
movl %edi, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm11, 0x18(%rsp)
mulsd %xmm11, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0x80(%rsp)
movl %ecx, 0x20(%rsp)
movslq %ecx, %rax
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x30(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0x38(%rsp)
movsd (%rdx), %xmm0
addsd %xmm5, %xmm0
movapd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rdx), %xmm0
addsd %xmm3, %xmm0
subsd 0x80(%rsp), %xmm0
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
cvtps2pd 0x164(%rax,%rbx), %xmm0
movsd 0x18(%rcx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
movsd 0x198(%rax), %xmm2
movhpd 0x1a0(%rax,%rbp,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0x30(%rsp), %r13
movl (%r13,%r12,4), %edx
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %r9, %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x11c881(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl (%r13,%r12,4), %xmm0
subsd 0x70(%rsp), %xmm0
divsd 0x78(%rsp), %xmm0
addsd 0x152ea6(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x1505e6(%rip), %xmm0 # 0x3a6db0
mulsd 0x1505e6(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x1505db(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x150575(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x13a283(%rip), %xmm0 # 0x390a90
addps 0xa0(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x38(%rsp), %xmm2
movsd 0x28(%rsp), %xmm5
movq 0x60(%rsp), %r9
movsd 0x12e8b0(%rip), %xmm3 # 0x3850f8
movq 0x213ba1(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
addsd %xmm3, %xmm2
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x2566d9
movl 0x20(%rsp), %ecx
addl %r12d, %ecx
movsd 0x18(%rsp), %xmm11
movl 0x10(%rsp), %edi
addsd %xmm3, %xmm11
incl %edi
cmpl 0xc(%rsp), %edi
jne 0x25668a
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<int, ImPlot::TransformerLogLog>(ImPlot::TransformerLogLog, ImDrawList&, int const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movl %r8d, 0xc(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
jle 0x257e68
movq %r9, 0xb8(%rsp)
movq 0x1a8(%rsp), %rdx
movq 0x1a0(%rsp), %r8
movsd (%rdx), %xmm4
movsd 0x8(%rdx), %xmm5
subsd (%r8), %xmm4
movl 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm3
subsd 0x8(%r8), %xmm5
cvtsi2sdl 0x8(%rsp), %xmm2
divsd %xmm3, %xmm4
divsd %xmm2, %xmm5
movsd 0x14f6a8(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm5, %xmm7
mulsd %xmm2, %xmm7
movq 0x212d19(%rip), %rcx # 0x46a3f0
movq (%rcx), %r14
movslq %edi, %rbp
subsd %xmm0, %xmm1
movl %eax, %eax
movq %rax, 0xd0(%rsp)
xorl %ecx, %ecx
movsd 0x14f673(%rip), %xmm6 # 0x3a6d68
movsd %xmm5, 0xa8(%rsp)
mulsd %xmm5, %xmm6
movsd %xmm6, 0xa0(%rsp)
movsd 0x14f655(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %r13
shlq $0x7, %r13
movq %rbp, %rax
shlq $0x4, %rax
movq %rax, 0xc8(%rsp)
movsd 0x12d9c3(%rip), %xmm5 # 0x3850f8
xorpd %xmm8, %xmm8
xorl %r9d, %r9d
movq %rsi, 0xe0(%rsp)
movsd %xmm4, 0xd8(%rsp)
movsd %xmm3, 0x58(%rsp)
movsd %xmm1, 0xe8(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm6, 0x130(%rsp)
movq %r14, 0x128(%rsp)
movsd %xmm0, 0xc0(%rsp)
movq 0xc8(%rsp), %rbx
cmpl $0x0, 0xc(%rsp)
jle 0x257b3c
movl %r9d, 0x6c(%rsp)
movsd 0xa8(%rsp), %xmm2
movsd %xmm8, 0x118(%rsp)
mulsd %xmm8, %xmm2
addsd 0xa0(%rsp), %xmm2
movsd %xmm2, 0x50(%rsp)
movq %rcx, 0x120(%rsp)
movslq %ecx, %rax
movq 0xb0(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x48(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0x90(%rsp)
movsd (%r8), %xmm0
addsd %xmm6, %xmm0
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x80(%rsp)
movsd 0x8(%rdx), %xmm1
subsd 0x50(%rsp), %xmm1
movsd %xmm1, 0x30(%rsp)
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
subsd %xmm7, %xmm1
movsd %xmm1, 0x20(%rsp)
movq %rbp, %r14
movq 0x212bc1(%rip), %rbp # 0x46a3f0
movq (%rbp), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x20(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0xf0(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x100(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0xf0(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x100(%rsp), %xmm0
movhpd 0x1c0(%r15,%r14,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x70(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm3
cvtps2pd %xmm0, %xmm0
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtps2pd 0x164(%r15,%rbx), %xmm2
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%r14,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x60(%rsp)
movsd 0x80(%rsp), %xmm1
addsd 0x58(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq (%rbp), %r15
movq %r14, %rbp
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm1
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x30(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x70(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x80(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0x70(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x20(%rsp), %xmm0
movhpd 0x1c0(%r15,%r14,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x80(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x30(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm3
cvtps2pd %xmm0, %xmm0
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtps2pd 0x164(%r15,%rbx), %xmm2
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%r14,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq 0x128(%rsp), %r14
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x138(%rsp)
movq 0x48(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r12,4), %xmm0
subsd 0xc0(%rsp), %xmm0
divsd 0xe8(%rsp), %xmm0
addsd 0x151bde(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x140(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
mulss 0x234(%r14), %xmm1
movss %xmm1, 0x14c(%rsp)
leaq 0x140(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq 0xe0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x138(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x90(%rsp), %xmm2
movsd 0x130(%rsp), %xmm6
movsd 0x10(%rsp), %xmm7
movq 0x1a8(%rsp), %rdx
movsd 0x12d602(%rip), %xmm5 # 0x3850f8
movsd 0x58(%rsp), %xmm3
movsd 0xd8(%rsp), %xmm4
movq 0x1a0(%rsp), %r8
addsd %xmm5, %xmm2
incq %r12
cmpl %r12d, 0xd0(%rsp)
jne 0x2577df
movq 0x120(%rsp), %rcx
addl %r12d, %ecx
movsd 0x118(%rsp), %xmm8
movl 0x6c(%rsp), %r9d
addsd %xmm5, %xmm8
incl %r9d
cmpl 0x8(%rsp), %r9d
jne 0x257785
cmpl $0x0, 0x8(%rsp)
setle %al
movq 0xb8(%rsp), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x257e68
leaq 0x140(%rsp), %r15
leaq 0x60(%rsp), %rbx
xorl %edx, %edx
xorpd %xmm10, %xmm10
xorl %esi, %esi
cmpl $0x0, 0xc(%rsp)
jle 0x257e57
movl %esi, 0x48(%rsp)
movsd 0xa8(%rsp), %xmm11
movsd %xmm10, 0x50(%rsp)
mulsd %xmm10, %xmm11
addsd 0xa0(%rsp), %xmm11
movsd %xmm11, 0x70(%rsp)
movl %edx, 0xf0(%rsp)
movslq %edx, %rax
movq 0xb0(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x100(%rsp)
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
movsd %xmm2, 0x30(%rsp)
movsd (%r8), %xmm1
addsd %xmm3, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd 0x8(%r8), %xmm1
addsd %xmm5, %xmm1
subsd 0x70(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %rbx, %r12
movq %r15, %rbx
movq 0x2127d4(%rip), %rax # 0x46a3f0
movq (%rax), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x10(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x80(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x80(%rsp), %xmm0
movhpd 0x1c0(%r15,%rbp,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x90(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
movq 0xc8(%rsp), %rcx
cvtps2pd 0x164(%r15,%rcx), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rbx, %r15
movq %r12, %rbx
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x100(%rsp), %r12
movl (%r12,%r14,4), %edx
movq %r15, %rdi
movq 0xb8(%rsp), %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x11b2ab(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl (%r12,%r14,4), %xmm0
subsd 0xc0(%rsp), %xmm0
divsd 0xe8(%rsp), %xmm0
addsd 0x1518cb(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x14f00b(%rip), %xmm0 # 0x3a6db0
mulsd 0x14f00b(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x14f000(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x14ef9a(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x138ca8(%rip), %xmm0 # 0x390a90
addps 0x10(%rsp), %xmm0
movlps %xmm0, 0x60(%rsp)
movq 0xe0(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x30(%rsp), %xmm2
movsd 0x12d2e2(%rip), %xmm5 # 0x3850f8
movsd 0x58(%rsp), %xmm3
movsd 0xd8(%rsp), %xmm4
movq 0x1a0(%rsp), %r8
addsd %xmm5, %xmm2
incq %r14
cmpl %r14d, 0xd0(%rsp)
jne 0x257bde
movl 0xf0(%rsp), %edx
addl %r14d, %edx
movsd 0x50(%rsp), %xmm10
movl 0x48(%rsp), %esi
addsd %xmm5, %xmm10
incl %esi
cmpl 0x8(%rsp), %esi
jne 0x257b83
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<unsigned int, ImPlot::TransformerLinLin>(ImPlot::TransformerLinLin, ImDrawList&, unsigned int const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0x14(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
jle 0x25857d
movq %rsi, 0x58(%rsp)
movq 0x148(%rsp), %r8
movq 0x140(%rsp), %rdx
movd 0xc(%rsp), %xmm3
movl 0x14(%rsp), %eax
movd %eax, %xmm2
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
cvtdq2pd %xmm2, %xmm3
movupd (%r8), %xmm4
movupd (%rdx), %xmm2
subpd %xmm2, %xmm4
divpd %xmm3, %xmm4
movapd 0x15170c(%rip), %xmm5 # 0x3a9780
mulpd %xmm4, %xmm5
movq 0x212371(%rip), %rsi # 0x46a3f0
movq (%rsi), %rcx
movslq %edi, %rbp
subsd %xmm0, %xmm1
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2 # xmm2 = xmm2[1],xmm4[1]
movl %eax, %eax
movq %rax, 0x68(%rsp)
xorpd %xmm8, %xmm8
xorl %eax, %eax
movsd 0x14ecc1(%rip), %xmm3 # 0x3a6d68
movapd %xmm2, 0xc0(%rsp)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x48(%rsp)
movsd 0x14eca6(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %rbx
shlq $0x4, %rbx
movq %rbp, %r15
shlq $0x7, %r15
movsd 0x12d01c(%rip), %xmm3 # 0x3850f8
xorpd %xmm7, %xmm7
xorl %r14d, %r14d
movapd %xmm4, 0xd0(%rsp)
movq %r9, 0x60(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm0, 0x70(%rsp)
movapd %xmm5, 0x80(%rsp)
movsd %xmm6, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x58(%rsp), %r13
cmpl $0x0, 0x14(%rsp)
jle 0x258328
movl %r14d, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm7, 0x18(%rsp)
mulsd %xmm7, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0xa0(%rsp)
movq %rax, 0x20(%rsp)
cltq
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x90(%rsp)
xorpd %xmm7, %xmm7
xorl %r12d, %r12d
movsd %xmm7, 0x38(%rsp)
movsd (%rdx), %xmm2
addsd %xmm6, %xmm2
movapd %xmm7, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm6
movsd 0x8(%r8), %xmm2
subsd 0xa0(%rsp), %xmm2
unpcklpd %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
movapd %xmm5, %xmm7
addpd %xmm6, %xmm7
subpd %xmm5, %xmm6
cvtps2pd 0x164(%rax,%rbx), %xmm2
movsd 0x18(%rcx), %xmm3
movapd %xmm3, %xmm4
movhpd 0x98(%rcx,%r15), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm6
movsd 0x198(%rax), %xmm4
movapd %xmm4, %xmm5
movhpd 0x1a0(%rax,%rbp,8), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd %xmm6, %xmm5
addpd %xmm2, %xmm5
cvtpd2ps %xmm5, %xmm2
movlpd %xmm2, 0x40(%rsp)
cvtps2pd 0x164(%rax,%rbx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm7
movhpd 0x1a0(%rax,%rbp,8), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm7, %xmm4
addpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm2
movlpd %xmm2, 0xb8(%rsp)
movq 0x90(%rsp), %rax
movl (%rax,%r12,4), %eax
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
subsd %xmm0, %xmm2
divsd %xmm1, %xmm2
addsd %xmm8, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movq %r15, %r14
movq %rbx, %r15
movq %rbp, %rbx
movq %r8, %rbp
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xe0(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movq 0x28(%rsp), %rax
mulss 0x234(%rax), %xmm1
movss %xmm1, 0xec(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x38(%rsp), %xmm7
movsd 0x30(%rsp), %xmm6
xorpd %xmm8, %xmm8
movapd 0x80(%rsp), %xmm5
movq %rbp, %r8
movq %rbx, %rbp
movq %r15, %rbx
movq %r14, %r15
movsd 0x12ce1e(%rip), %xmm3 # 0x3850f8
movq 0x21210f(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
addsd %xmm3, %xmm7
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x258167
movq 0x20(%rsp), %rax
addl %r12d, %eax
movq 0x60(%rsp), %r9
movsd 0x18(%rsp), %xmm7
movl 0x10(%rsp), %r14d
addsd %xmm3, %xmm7
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x258116
cmpl $0x0, 0xc(%rsp)
setle %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x25857d
movsd 0x14ea10(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
xorl %ecx, %ecx
xorpd %xmm11, %xmm11
xorl %edi, %edi
movsd %xmm5, 0x28(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x25856c
movl %edi, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm11, 0x18(%rsp)
mulsd %xmm11, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0x80(%rsp)
movl %ecx, 0x20(%rsp)
movslq %ecx, %rax
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x30(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0x38(%rsp)
movsd (%rdx), %xmm0
addsd %xmm5, %xmm0
movapd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rdx), %xmm0
addsd %xmm3, %xmm0
subsd 0x80(%rsp), %xmm0
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
cvtps2pd 0x164(%rax,%rbx), %xmm0
movsd 0x18(%rcx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
movsd 0x198(%rax), %xmm2
movhpd 0x1a0(%rax,%rbp,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0x30(%rsp), %r13
movl (%r13,%r12,4), %edx
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %r9, %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x11ab9c(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
movl (%r13,%r12,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd 0x70(%rsp), %xmm0
divsd 0x78(%rsp), %xmm0
addsd 0x1511be(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x14e8fe(%rip), %xmm0 # 0x3a6db0
mulsd 0x14e8fe(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x14e8f3(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x14e88d(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x13859b(%rip), %xmm0 # 0x390a90
addps 0xa0(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x38(%rsp), %xmm2
movsd 0x28(%rsp), %xmm5
movq 0x60(%rsp), %r9
movsd 0x12cbc8(%rip), %xmm3 # 0x3850f8
movq 0x211eb9(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
addsd %xmm3, %xmm2
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x2583be
movl 0x20(%rsp), %ecx
addl %r12d, %ecx
movsd 0x18(%rsp), %xmm11
movl 0x10(%rsp), %edi
addsd %xmm3, %xmm11
incl %edi
cmpl 0xc(%rsp), %edi
jne 0x25836f
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<unsigned int, ImPlot::TransformerLinLog>(ImPlot::TransformerLinLog, ImDrawList&, unsigned int const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %r8d, 0xc(%rsp)
movq %rdx, 0x88(%rsp)
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
jle 0x25932e
movq %r9, 0x90(%rsp)
movq 0x178(%rsp), %rdx
movq 0x170(%rsp), %r8
movsd (%rdx), %xmm4
movsd 0x8(%rdx), %xmm5
subsd (%r8), %xmm4
movl 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm3
subsd 0x8(%r8), %xmm5
cvtsi2sdl 0x8(%rsp), %xmm2
divsd %xmm3, %xmm4
divsd %xmm2, %xmm5
movsd 0x14e0a0(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm5, %xmm7
mulsd %xmm2, %xmm7
movq 0x211711(%rip), %rcx # 0x46a3f0
movq (%rcx), %r15
movslq %edi, %rbp
subsd %xmm0, %xmm1
movl %eax, %eax
movq %rax, 0xa8(%rsp)
xorl %eax, %eax
movsd 0x14e06b(%rip), %xmm6 # 0x3a6d68
movsd %xmm5, 0x80(%rsp)
mulsd %xmm5, %xmm6
movsd %xmm6, 0x78(%rsp)
movsd 0x14e050(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %r14
shlq $0x7, %r14
movq %rbp, %r11
shlq $0x4, %r11
movsd 0x12c3c6(%rip), %xmm5 # 0x3850f8
xorpd %xmm8, %xmm8
xorl %r10d, %r10d
movq %rsi, 0xb0(%rsp)
movsd %xmm3, 0x48(%rsp)
movsd %xmm1, 0xb8(%rsp)
movapd %xmm4, 0x100(%rsp)
movsd %xmm7, 0x60(%rsp)
movsd %xmm6, 0x28(%rsp)
movq %r11, 0xa0(%rsp)
movq %r15, 0x20(%rsp)
movsd %xmm0, 0x98(%rsp)
movq 0xa0(%rsp), %r13
cmpl $0x0, 0xc(%rsp)
jle 0x259063
movl %r10d, 0x5c(%rsp)
movsd 0x80(%rsp), %xmm2
movsd %xmm8, 0xe8(%rsp)
mulsd %xmm8, %xmm2
addsd 0x78(%rsp), %xmm2
movsd %xmm2, 0x38(%rsp)
movq %rax, 0xf0(%rsp)
cltq
movq 0x88(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x30(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0xd0(%rsp)
movsd (%r8), %xmm0
addsd %xmm6, %xmm0
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
movsd 0x8(%rdx), %xmm0
subsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
subsd %xmm3, %xmm2
movapd %xmm2, 0xc0(%rsp)
subsd %xmm7, %xmm0
movq %r14, %rbx
movq 0x2115ca(%rip), %r14 # 0x46a3f0
movq (%r14), %r15
movq 0x28(%r15), %rax
divsd 0x98(%rax,%rbx), %xmm0
callq 0xe2ca0
divsd 0x1c0(%r15,%rbp,8), %xmm0
movq 0x28(%r15), %rax
movsd 0x98(%rax,%rbx), %xmm1
movsd 0xa0(%rax,%rbx), %xmm2
cvtsd2ss %xmm0, %xmm0
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movapd 0xc0(%rsp), %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
cvtps2pd 0x164(%r15,%r13), %xmm0
movsd 0x18(%rax), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm3
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm3, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x50(%rsp)
movapd 0x10(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
addsd 0x60(%rsp), %xmm0
movq (%r14), %r15
movq %rbx, %r14
movq 0x28(%r15), %rax
divsd 0x98(%rax,%rbx), %xmm0
callq 0xe2ca0
divsd 0x1c0(%r15,%rbp,8), %xmm0
movq 0x28(%r15), %rax
movsd 0x98(%rax,%rbx), %xmm1
movsd 0xa0(%rax,%rbx), %xmm2
cvtsd2ss %xmm0, %xmm0
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtps2pd 0x164(%r15,%r13), %xmm2
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
movsd 0x18(%rax), %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
subpd %xmm0, %xmm3
movsd 0x198(%r15), %xmm0
movhpd 0x1a0(%r15,%rbp,8), %xmm0 # xmm0 = xmm0[0],mem[0]
movq 0x20(%rsp), %r15
leaq 0x110(%rsp), %rbx
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0xf8(%rsp)
movq 0x30(%rsp), %rax
movl (%rax,%r12,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd 0x98(%rsp), %xmm0
divsd 0xb8(%rsp), %xmm0
addsd 0x1506af(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x110(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
mulss 0x234(%r15), %xmm1
movss %xmm1, 0x11c(%rsp)
movq %rbx, %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0xf8(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0xd0(%rsp), %xmm2
movsd 0x28(%rsp), %xmm6
movsd 0x60(%rsp), %xmm7
movq 0x178(%rsp), %rdx
movsd 0x12c0db(%rip), %xmm5 # 0x3850f8
movsd 0x48(%rsp), %xmm3
movapd 0x100(%rsp), %xmm4
movq 0x170(%rsp), %r8
addsd %xmm5, %xmm2
incq %r12
cmpl %r12d, 0xa8(%rsp)
jne 0x258dda
movq 0xf0(%rsp), %rax
addl %r12d, %eax
movsd 0xe8(%rsp), %xmm8
movl 0x5c(%rsp), %r10d
addsd %xmm5, %xmm8
incl %r10d
cmpl 0x8(%rsp), %r10d
jne 0x258d84
movq %rbp, 0x20(%rsp)
cmpl $0x0, 0x8(%rsp)
setle %al
movq 0x90(%rsp), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x25932e
leaq 0x110(%rsp), %r15
leaq 0x50(%rsp), %rbx
xorl %ecx, %ecx
xorpd %xmm10, %xmm10
xorl %edx, %edx
movq 0x20(%rsp), %rbp
cmpl $0x0, 0xc(%rsp)
jle 0x25931d
movl %edx, 0x28(%rsp)
movsd 0x80(%rsp), %xmm11
movsd %xmm10, 0x30(%rsp)
mulsd %xmm10, %xmm11
addsd 0x78(%rsp), %xmm11
movsd %xmm11, 0x40(%rsp)
movl %ecx, 0x38(%rsp)
movslq %ecx, %rax
movq 0x88(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0xc0(%rsp)
xorpd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
xorl %r12d, %r12d
movsd (%r8), %xmm0
addsd %xmm3, %xmm0
movapd %xmm0, 0x60(%rsp)
movsd 0x8(%r8), %xmm0
addsd %xmm5, %xmm0
subsd 0x40(%rsp), %xmm0
movq %rbx, %r13
movq %r15, %rbx
movq 0x2112b5(%rip), %rax # 0x46a3f0
movq (%rax), %r15
movq 0x28(%r15), %rax
divsd 0x98(%rax,%r14), %xmm0
callq 0xe2ca0
divsd 0x1c0(%r15,%rbp,8), %xmm0
movq 0x28(%r15), %rax
movsd 0x98(%rax,%r14), %xmm1
movsd 0xa0(%rax,%r14), %xmm2
cvtsd2ss %xmm0, %xmm0
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
movaps 0x100(%rsp), %xmm2
movlhps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm3, %xmm2
movapd 0x60(%rsp), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movq 0xa0(%rsp), %rcx
cvtps2pd 0x164(%r15,%rcx), %xmm0
addpd %xmm2, %xmm3
movsd 0x18(%rax), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm3
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rbx, %r15
movq %r13, %rbx
mulpd %xmm3, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, 0x60(%rsp)
movq 0xc0(%rsp), %r13
movl (%r13,%r12,4), %edx
movq %r15, %rdi
movq 0x90(%rsp), %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x119de3(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0xd0(%rsp)
movl (%r13,%r12,4), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd 0x98(%rsp), %xmm0
divsd 0xb8(%rsp), %xmm0
addsd 0x1503ff(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x14db3f(%rip), %xmm0 # 0x3a6db0
mulsd 0x14db3f(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x14db34(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x14dace(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0xd0(%rsp), %xmm0
mulps 0x1377dc(%rip), %xmm0 # 0x390a90
addps 0x60(%rsp), %xmm0
movlps %xmm0, 0x50(%rsp)
movq 0xb0(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x12be1c(%rip), %xmm5 # 0x3850f8
movsd 0x48(%rsp), %xmm3
movq 0x170(%rsp), %r8
movapd 0x10(%rsp), %xmm0
addsd %xmm5, %xmm0
movapd %xmm0, 0x10(%rsp)
incq %r12
cmpl %r12d, 0xa8(%rsp)
jne 0x25910f
movl 0x38(%rsp), %ecx
addl %r12d, %ecx
movsd 0x30(%rsp), %xmm10
movl 0x28(%rsp), %edx
addsd %xmm5, %xmm10
incl %edx
cmpl 0x8(%rsp), %edx
jne 0x2590b4
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<long long, ImPlot::TransformerLogLin>(ImPlot::TransformerLogLin, ImDrawList&, long long const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %r8d, 0xc(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
jle 0x25a938
movq %r9, 0x78(%rsp)
movq 0x178(%rsp), %rdx
movq 0x170(%rsp), %r8
movsd (%rdx), %xmm4
movsd 0x8(%rdx), %xmm5
subsd (%r8), %xmm4
movl 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm3
subsd 0x8(%r8), %xmm5
cvtsi2sdl 0x8(%rsp), %xmm2
divsd %xmm3, %xmm4
divsd %xmm2, %xmm5
movsd 0x14ca6f(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm5, %xmm7
mulsd %xmm2, %xmm7
movq 0x2100e0(%rip), %rcx # 0x46a3f0
movq (%rcx), %r14
movslq %edi, %r11
subsd %xmm0, %xmm1
movl %eax, %eax
movq %rax, 0xa0(%rsp)
xorl %eax, %eax
movsd 0x14ca3a(%rip), %xmm6 # 0x3a6d68
movsd %xmm5, 0x68(%rsp)
mulsd %xmm5, %xmm6
movsd %xmm6, 0x60(%rsp)
movsd 0x14ca22(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %r11, %rbx
shlq $0x4, %rbx
movq %r11, %rbp
shlq $0x7, %rbp
movsd 0x12ad98(%rip), %xmm5 # 0x3850f8
xorpd %xmm8, %xmm8
xorl %r10d, %r10d
movq %rsi, 0xb0(%rsp)
movsd %xmm4, 0xa8(%rsp)
movsd %xmm3, 0x28(%rsp)
movsd %xmm1, 0xb8(%rsp)
movsd %xmm7, 0x40(%rsp)
movsd %xmm6, 0x100(%rsp)
movq %r11, 0x88(%rsp)
movq %rbp, 0x80(%rsp)
movq %rbx, 0x98(%rsp)
movq %r14, 0xf8(%rsp)
movsd %xmm0, 0x90(%rsp)
movq 0x98(%rsp), %r13
cmpl $0x0, 0xc(%rsp)
jle 0x25a6aa
movl %r10d, 0x3c(%rsp)
movsd 0x68(%rsp), %xmm2
movsd %xmm8, 0xe8(%rsp)
mulsd %xmm8, %xmm2
addsd 0x60(%rsp), %xmm2
movsd %xmm2, 0x18(%rsp)
movq %rax, 0xf0(%rsp)
cltq
movq 0x70(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0xd0(%rsp)
movsd (%r8), %xmm0
addsd %xmm6, %xmm0
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x20(%rsp)
movsd 0x8(%rdx), %xmm1
subsd 0x18(%rsp), %xmm1
movapd %xmm1, 0x50(%rsp)
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
subsd %xmm7, %xmm1
movapd %xmm1, 0xc0(%rsp)
movq 0x20ff8b(%rip), %r14 # 0x46a3f0
movq (%r14), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r15), %xmm0
movq 0x28(%r15), %rax
cvtsd2ss %xmm0, %xmm0
movupd 0x18(%rax), %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd 0xc0(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
cvtps2pd 0x164(%r15,%r13), %xmm2
movq 0x80(%rsp), %rbp
movhpd 0x98(%rax,%rbp), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%r15), %xmm1
movq 0x88(%rsp), %rbx
movhpd 0x1a0(%r15,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x30(%rsp)
movsd 0x20(%rsp), %xmm1
addsd 0x28(%rsp), %xmm1
movapd 0x50(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
movapd %xmm0, 0x50(%rsp)
movq (%r14), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm1
movapd %xmm1, %xmm0
callq 0xe2ca0
divsd 0x1b8(%r15), %xmm0
movq 0x28(%r15), %rax
cvtsd2ss %xmm0, %xmm0
movupd 0x18(%rax), %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd 0x50(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
cvtps2pd 0x164(%r15,%r13), %xmm2
movhpd 0x98(%rax,%rbp), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq 0xf8(%rsp), %r14
leaq 0x110(%rsp), %rbx
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x108(%rsp)
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%r12,8), %xmm0
subsd 0x90(%rsp), %xmm0
divsd 0xb8(%rsp), %xmm0
addsd 0x14f07b(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x110(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
mulss 0x234(%r14), %xmm1
movss %xmm1, 0x11c(%rsp)
movq %rbx, %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x108(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0xd0(%rsp), %xmm2
movsd 0x100(%rsp), %xmm6
movsd 0x40(%rsp), %xmm7
movq 0x178(%rsp), %rdx
movsd 0x12aaa4(%rip), %xmm5 # 0x3850f8
movsd 0x28(%rsp), %xmm3
movsd 0xa8(%rsp), %xmm4
movq 0x170(%rsp), %r8
addsd %xmm5, %xmm2
incq %r12
cmpl %r12d, 0xa0(%rsp)
jne 0x25a418
movq 0xf0(%rsp), %rax
addl %r12d, %eax
movq 0x88(%rsp), %r11
movq 0x80(%rsp), %rbp
movsd 0xe8(%rsp), %xmm8
movl 0x3c(%rsp), %r10d
addsd %xmm5, %xmm8
incl %r10d
cmpl 0x8(%rsp), %r10d
jne 0x25a3c8
cmpl $0x0, 0x8(%rsp)
setle %al
movq 0x78(%rsp), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x25a938
leaq 0x110(%rsp), %r15
xorl %ecx, %ecx
xorpd %xmm10, %xmm10
xorl %esi, %esi
cmpl $0x0, 0xc(%rsp)
jle 0x25a927
movl %esi, 0x10(%rsp)
movsd 0x68(%rsp), %xmm11
movsd %xmm10, 0x18(%rsp)
mulsd %xmm10, %xmm11
addsd 0x60(%rsp), %xmm11
movsd %xmm11, 0x20(%rsp)
movl %ecx, 0xc0(%rsp)
movslq %ecx, %rax
movq 0x70(%rsp), %rcx
leaq (%rcx,%rax,8), %r13
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movq %r11, %r14
movsd %xmm2, 0x50(%rsp)
movsd (%r8), %xmm1
addsd %xmm3, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd 0x8(%r8), %xmm1
addsd %xmm5, %xmm1
subsd 0x20(%rsp), %xmm1
movapd %xmm1, 0x40(%rsp)
movq %r15, %rbx
movq 0x20fc7f(%rip), %rax # 0x46a3f0
movq (%rax), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r15), %xmm0
movq 0x28(%r15), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x98(%rsp), %rcx
cvtps2pd 0x164(%r15,%rcx), %xmm2
unpcklpd 0x40(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movhpd 0x98(%rax,%rbp), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%r14,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rbx, %r15
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, 0x40(%rsp)
movq (%r13,%r12,8), %rdx
movq %rbx, %rdi
movq 0x78(%rsp), %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x1187e1(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0xd0(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdq (%r13,%r12,8), %xmm0
subsd 0x90(%rsp), %xmm0
divsd 0xb8(%rsp), %xmm0
addsd 0x14ee00(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x14c540(%rip), %xmm0 # 0x3a6db0
mulsd 0x14c540(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x14c535(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x14c4cf(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0xd0(%rsp), %xmm0
mulps 0x1361dd(%rip), %xmm0 # 0x390a90
addps 0x40(%rsp), %xmm0
movlps %xmm0, 0x30(%rsp)
movq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x50(%rsp), %xmm2
movsd 0x12a815(%rip), %xmm5 # 0x3850f8
movsd 0x28(%rsp), %xmm3
movsd 0xa8(%rsp), %xmm4
movq 0x170(%rsp), %r8
addsd %xmm5, %xmm2
incq %r12
cmpl %r12d, 0xa0(%rsp)
jne 0x25a736
movl 0xc0(%rsp), %ecx
addl %r12d, %ecx
movq %r14, %r11
movsd 0x18(%rsp), %xmm10
movl 0x10(%rsp), %esi
addsd %xmm5, %xmm10
incl %esi
cmpl 0x8(%rsp), %esi
jne 0x25a6e9
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<long long, ImPlot::TransformerLogLog>(ImPlot::TransformerLogLog, ImDrawList&, long long const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movl %r8d, 0xc(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
jle 0x25b84c
movq %r9, 0xb8(%rsp)
movq 0x1a8(%rsp), %rdx
movq 0x1a0(%rsp), %r8
movsd (%rdx), %xmm4
movsd 0x8(%rdx), %xmm5
subsd (%r8), %xmm4
movl 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm3
subsd 0x8(%r8), %xmm5
cvtsi2sdl 0x8(%rsp), %xmm2
divsd %xmm3, %xmm4
divsd %xmm2, %xmm5
movsd 0x14bcc4(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm5, %xmm7
mulsd %xmm2, %xmm7
movq 0x20f335(%rip), %rcx # 0x46a3f0
movq (%rcx), %r14
movslq %edi, %rbp
subsd %xmm0, %xmm1
movl %eax, %eax
movq %rax, 0xd0(%rsp)
xorl %ecx, %ecx
movsd 0x14bc8f(%rip), %xmm6 # 0x3a6d68
movsd %xmm5, 0xa8(%rsp)
mulsd %xmm5, %xmm6
movsd %xmm6, 0xa0(%rsp)
movsd 0x14bc71(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %r13
shlq $0x7, %r13
movq %rbp, %rax
shlq $0x4, %rax
movq %rax, 0xc8(%rsp)
movsd 0x129fdf(%rip), %xmm5 # 0x3850f8
xorpd %xmm8, %xmm8
xorl %r9d, %r9d
movq %rsi, 0xe0(%rsp)
movsd %xmm4, 0xd8(%rsp)
movsd %xmm3, 0x58(%rsp)
movsd %xmm1, 0xe8(%rsp)
movsd %xmm7, 0x10(%rsp)
movsd %xmm6, 0x130(%rsp)
movq %r14, 0x128(%rsp)
movsd %xmm0, 0xc0(%rsp)
movq 0xc8(%rsp), %rbx
cmpl $0x0, 0xc(%rsp)
jle 0x25b520
movl %r9d, 0x6c(%rsp)
movsd 0xa8(%rsp), %xmm2
movsd %xmm8, 0x118(%rsp)
mulsd %xmm8, %xmm2
addsd 0xa0(%rsp), %xmm2
movsd %xmm2, 0x50(%rsp)
movq %rcx, 0x120(%rsp)
movslq %ecx, %rax
movq 0xb0(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x48(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0x90(%rsp)
movsd (%r8), %xmm0
addsd %xmm6, %xmm0
mulsd %xmm4, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x80(%rsp)
movsd 0x8(%rdx), %xmm1
subsd 0x50(%rsp), %xmm1
movsd %xmm1, 0x30(%rsp)
movapd %xmm2, %xmm0
subsd %xmm3, %xmm0
subsd %xmm7, %xmm1
movsd %xmm1, 0x20(%rsp)
movq %rbp, %r14
movq 0x20f1dd(%rip), %rbp # 0x46a3f0
movq (%rbp), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x20(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0xf0(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x100(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0xf0(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x100(%rsp), %xmm0
movhpd 0x1c0(%r15,%r14,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x70(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm3
cvtps2pd %xmm0, %xmm0
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtps2pd 0x164(%r15,%rbx), %xmm2
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%r14,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x60(%rsp)
movsd 0x80(%rsp), %xmm1
addsd 0x58(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq (%rbp), %r15
movq %r14, %rbp
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm1
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x30(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x70(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x80(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0x70(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x20(%rsp), %xmm0
movhpd 0x1c0(%r15,%r14,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x80(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x30(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
subpd %xmm2, %xmm3
cvtps2pd %xmm0, %xmm0
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
cvtps2pd 0x164(%r15,%rbx), %xmm2
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%r14,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq 0x128(%rsp), %r14
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x138(%rsp)
movq 0x48(%rsp), %rax
xorps %xmm0, %xmm0
cvtsi2sdq (%rax,%r12,8), %xmm0
subsd 0xc0(%rsp), %xmm0
divsd 0xe8(%rsp), %xmm0
addsd 0x14e1fa(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x140(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
mulss 0x234(%r14), %xmm1
movss %xmm1, 0x14c(%rsp)
leaq 0x140(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq 0xe0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x138(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x90(%rsp), %xmm2
movsd 0x130(%rsp), %xmm6
movsd 0x10(%rsp), %xmm7
movq 0x1a8(%rsp), %rdx
movsd 0x129c1e(%rip), %xmm5 # 0x3850f8
movsd 0x58(%rsp), %xmm3
movsd 0xd8(%rsp), %xmm4
movq 0x1a0(%rsp), %r8
addsd %xmm5, %xmm2
incq %r12
cmpl %r12d, 0xd0(%rsp)
jne 0x25b1c3
movq 0x120(%rsp), %rcx
addl %r12d, %ecx
movsd 0x118(%rsp), %xmm8
movl 0x6c(%rsp), %r9d
addsd %xmm5, %xmm8
incl %r9d
cmpl 0x8(%rsp), %r9d
jne 0x25b169
cmpl $0x0, 0x8(%rsp)
setle %al
movq 0xb8(%rsp), %rdx
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x25b84c
leaq 0x140(%rsp), %r15
leaq 0x60(%rsp), %rbx
xorl %edx, %edx
xorpd %xmm10, %xmm10
xorl %esi, %esi
cmpl $0x0, 0xc(%rsp)
jle 0x25b83b
movl %esi, 0x48(%rsp)
movsd 0xa8(%rsp), %xmm11
movsd %xmm10, 0x50(%rsp)
mulsd %xmm10, %xmm11
addsd 0xa0(%rsp), %xmm11
movsd %xmm11, 0x70(%rsp)
movl %edx, 0xf0(%rsp)
movslq %edx, %rax
movq 0xb0(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x100(%rsp)
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
movsd %xmm2, 0x30(%rsp)
movsd (%r8), %xmm1
addsd %xmm3, %xmm1
movapd %xmm2, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd 0x8(%r8), %xmm1
addsd %xmm5, %xmm1
subsd 0x70(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %rbx, %r12
movq %r15, %rbx
movq 0x20edf0(%rip), %rax # 0x46a3f0
movq (%rax), %r15
movq 0x28(%r15), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movsd 0x10(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r15), %xmm0
movaps %xmm0, 0x80(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r15), %rax
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x80(%rsp), %xmm0
movhpd 0x1c0(%r15,%rbp,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x90(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
movq 0xc8(%rsp), %rcx
cvtps2pd 0x164(%r15,%rcx), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r15), %xmm1
movhpd 0x1a0(%r15,%rbp,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rbx, %r15
movq %r12, %rbx
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x100(%rsp), %r12
movq (%r12,%r14,8), %rdx
movq %r15, %rdi
movq 0xb8(%rsp), %rsi
xorl %eax, %eax
callq 0xe0ca0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x1178c7(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdq (%r12,%r14,8), %xmm0
subsd 0xc0(%rsp), %xmm0
divsd 0xe8(%rsp), %xmm0
addsd 0x14dee7(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x14b627(%rip), %xmm0 # 0x3a6db0
mulsd 0x14b627(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x14b61c(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x14b5b6(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x1352c4(%rip), %xmm0 # 0x390a90
addps 0x10(%rsp), %xmm0
movlps %xmm0, 0x60(%rsp)
movq 0xe0(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x30(%rsp), %xmm2
movsd 0x1298fe(%rip), %xmm5 # 0x3850f8
movsd 0x58(%rsp), %xmm3
movsd 0xd8(%rsp), %xmm4
movq 0x1a0(%rsp), %r8
addsd %xmm5, %xmm2
incq %r14
cmpl %r14d, 0xd0(%rsp)
jne 0x25b5c2
movl 0xf0(%rsp), %edx
addl %r14d, %edx
movsd 0x50(%rsp), %xmm10
movl 0x48(%rsp), %esi
addsd %xmm5, %xmm10
incl %esi
cmpl 0x8(%rsp), %esi
jne 0x25b567
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderHeatmap<float, ImPlot::TransformerLinLin>(ImPlot::TransformerLinLin, ImDrawList&, float const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void RenderHeatmap(Transformer transformer, ImDrawList& DrawList, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
ImPlotContext& gp = *GImPlot;
const double w = (bounds_max.x - bounds_min.x) / cols;
const double h = (bounds_max.y - bounds_min.y) / rows;
const ImPlotPoint half_size(w*0.5,h*0.5);
int i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_max.y - (0.5*h + r*h);
ImVec2 a = transformer(ImPlotPoint(p.x - half_size.x, p.y - half_size.y));
ImVec2 b = transformer(ImPlotPoint(p.x + half_size.x, p.y + half_size.y));
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
color.w *= gp.Style.FillAlpha;
ImU32 col = ImGui::GetColorU32(color);
DrawList.AddRectFilled(a, b, col);
i++;
}
}
if (fmt != NULL) {
i = 0;
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
ImPlotPoint p;
p.x = bounds_min.x + 0.5*w + c*w;
p.y = bounds_min.y + 1 - (0.5*h + r*h);
ImVec2 px = transformer(p);
char buff[32];
sprintf(buff, fmt, values[i]);
ImVec2 size = ImGui::CalcTextSize(buff);
double t = ImRemap((double)values[i], scale_min, scale_max, 0.0, 1.0);
ImVec4 color = LerpColormap((float)t);
ImU32 col = CalcTextColor(color);
DrawList.AddText(px - size * 0.5f, col, buff);
i++;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, 0x14(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
jle 0x25dd92
movq %rsi, 0x58(%rsp)
movq 0x148(%rsp), %r8
movq 0x140(%rsp), %rdx
movd 0xc(%rsp), %xmm3
movl 0x14(%rsp), %eax
movd %eax, %xmm2
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
cvtdq2pd %xmm2, %xmm3
movupd (%r8), %xmm4
movupd (%rdx), %xmm2
subpd %xmm2, %xmm4
divpd %xmm3, %xmm4
movapd 0x14bef7(%rip), %xmm5 # 0x3a9780
mulpd %xmm4, %xmm5
movq 0x20cb5c(%rip), %rsi # 0x46a3f0
movq (%rsi), %rcx
movslq %edi, %rbp
subsd %xmm0, %xmm1
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2 # xmm2 = xmm2[1],xmm4[1]
movl %eax, %eax
movq %rax, 0x68(%rsp)
xorpd %xmm8, %xmm8
xorl %eax, %eax
movsd 0x1494ac(%rip), %xmm3 # 0x3a6d68
movapd %xmm2, 0xc0(%rsp)
mulsd %xmm2, %xmm3
movsd %xmm3, 0x48(%rsp)
movsd 0x149491(%rip), %xmm6 # 0x3a6d68
mulsd %xmm4, %xmm6
movq %rbp, %rbx
shlq $0x4, %rbx
movq %rbp, %r15
shlq $0x7, %r15
movsd 0x127807(%rip), %xmm3 # 0x3850f8
xorpd %xmm7, %xmm7
xorl %r14d, %r14d
movapd %xmm4, 0xd0(%rsp)
movq %r9, 0x60(%rsp)
movsd %xmm1, 0x78(%rsp)
movsd %xmm0, 0x70(%rsp)
movapd %xmm5, 0x80(%rsp)
movsd %xmm6, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x58(%rsp), %r13
cmpl $0x0, 0x14(%rsp)
jle 0x25db3a
movl %r14d, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm7, 0x18(%rsp)
mulsd %xmm7, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0xa0(%rsp)
movq %rax, 0x20(%rsp)
cltq
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x90(%rsp)
xorpd %xmm7, %xmm7
xorl %r12d, %r12d
movsd %xmm7, 0x38(%rsp)
movsd (%rdx), %xmm2
addsd %xmm6, %xmm2
movapd %xmm7, %xmm6
mulsd %xmm4, %xmm6
addsd %xmm2, %xmm6
movsd 0x8(%r8), %xmm2
subsd 0xa0(%rsp), %xmm2
unpcklpd %xmm2, %xmm6 # xmm6 = xmm6[0],xmm2[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
movapd %xmm5, %xmm7
addpd %xmm6, %xmm7
subpd %xmm5, %xmm6
cvtps2pd 0x164(%rax,%rbx), %xmm2
movsd 0x18(%rcx), %xmm3
movapd %xmm3, %xmm4
movhpd 0x98(%rcx,%r15), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm6
movsd 0x198(%rax), %xmm4
movapd %xmm4, %xmm5
movhpd 0x1a0(%rax,%rbp,8), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd %xmm6, %xmm5
addpd %xmm2, %xmm5
cvtpd2ps %xmm5, %xmm2
movlpd %xmm2, 0x40(%rsp)
cvtps2pd 0x164(%rax,%rbx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm7
movhpd 0x1a0(%rax,%rbp,8), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm7, %xmm4
addpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm2
movlpd %xmm2, 0xb8(%rsp)
movq 0x90(%rsp), %rax
xorps %xmm2, %xmm2
cvtss2sd (%rax,%r12,4), %xmm2
subsd %xmm0, %xmm2
divsd %xmm1, %xmm2
addsd %xmm8, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movq %r15, %r14
movq %rbx, %r15
movq %rbp, %rbx
movq %r8, %rbp
callq 0xeca98
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0xe0(%rsp)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movq 0x28(%rsp), %rax
mulss 0x234(%rax), %xmm1
movss %xmm1, 0xec(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0xe7f80
xorps %xmm0, %xmm0
movq %r13, %rdi
leaq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
movl %eax, %ecx
movl $0xf, %r8d
callq 0xe3d60
movsd 0x38(%rsp), %xmm7
movsd 0x30(%rsp), %xmm6
xorpd %xmm8, %xmm8
movapd 0x80(%rsp), %xmm5
movq %rbp, %r8
movq %rbx, %rbp
movq %r15, %rbx
movq %r14, %r15
movsd 0x12760c(%rip), %xmm3 # 0x3850f8
movq 0x20c8fd(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
movsd 0x70(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
addsd %xmm3, %xmm7
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x25d97c
movq 0x20(%rsp), %rax
addl %r12d, %eax
movq 0x60(%rsp), %r9
movsd 0x18(%rsp), %xmm7
movl 0x10(%rsp), %r14d
addsd %xmm3, %xmm7
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x25d92b
cmpl $0x0, 0xc(%rsp)
setle %al
testq %r9, %r9
sete %cl
orb %al, %cl
jne 0x25dd92
xorl %eax, %eax
movsd 0x1491fc(%rip), %xmm2 # 0x3a6d68
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
xorpd %xmm11, %xmm11
xorl %edi, %edi
movsd %xmm5, 0x28(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x25dd81
movl %edi, 0x10(%rsp)
movapd 0xc0(%rsp), %xmm2
movsd %xmm11, 0x18(%rsp)
mulsd %xmm11, %xmm2
addsd 0x48(%rsp), %xmm2
movsd %xmm2, 0x80(%rsp)
movq %rax, 0x20(%rsp)
cltq
movq 0x50(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
movq %rax, 0x30(%rsp)
xorpd %xmm2, %xmm2
xorl %r12d, %r12d
movsd %xmm2, 0x38(%rsp)
movsd (%rdx), %xmm0
addsd %xmm5, %xmm0
movapd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm0, %xmm1
movsd 0x8(%rdx), %xmm0
addsd %xmm3, %xmm0
subsd 0x80(%rsp), %xmm0
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq (%rsi), %rax
movq 0x28(%rax), %rcx
cvtps2pd 0x164(%rax,%rbx), %xmm0
movsd 0x18(%rcx), %xmm2
movhpd 0x98(%rcx,%r15), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
movsd 0x198(%rax), %xmm2
movhpd 0x1a0(%rax,%rbp,8), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
addpd %xmm0, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0x30(%rsp), %r13
xorps %xmm0, %xmm0
cvtss2sd (%r13,%r12,4), %xmm0
leaq 0xe0(%rsp), %r14
movq %r14, %rdi
movq %r9, %rsi
movb $0x1, %al
callq 0xe0ca0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movss 0x115385(%rip), %xmm0 # 0x373000
callq 0xec8f8
movaps %xmm0, 0x90(%rsp)
xorps %xmm0, %xmm0
cvtss2sd (%r13,%r12,4), %xmm0
subsd 0x70(%rsp), %xmm0
divsd 0x78(%rsp), %xmm0
addsd 0x14b9aa(%rip), %xmm0 # 0x3a9650
cvtsd2ss %xmm0, %xmm0
callq 0xeca98
xorps %xmm2, %xmm2
cvtss2sd %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
cvtss2sd %xmm0, %xmm0
mulsd 0x1490ea(%rip), %xmm0 # 0x3a6db0
mulsd 0x1490ea(%rip), %xmm2 # 0x3a6db8
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd 0x1490df(%rip), %xmm0 # 0x3a6dc0
addsd %xmm2, %xmm0
xorl %edx, %edx
ucomisd 0x149079(%rip), %xmm0 # 0x3a6d68
setbe %dl
negl %edx
orl $0xff000000, %edx # imm = 0xFF000000
movaps 0x90(%rsp), %xmm0
mulps 0x132d87(%rip), %xmm0 # 0x390a90
addps 0xa0(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xe4a80
movsd 0x38(%rsp), %xmm2
movsd 0x28(%rsp), %xmm5
movq 0x60(%rsp), %r9
movsd 0x1273b4(%rip), %xmm3 # 0x3850f8
movq 0x20c6a5(%rip), %rsi # 0x46a3f0
movapd 0xd0(%rsp), %xmm4
movq 0x140(%rsp), %rdx
addsd %xmm3, %xmm2
incq %r12
cmpl %r12d, 0x68(%rsp)
jne 0x25dbd0
movq 0x20(%rsp), %rax
addl %r12d, %eax
movsd 0x18(%rsp), %xmm11
movl 0x10(%rsp), %edi
addsd %xmm3, %xmm11
incl %edi
cmpl 0xc(%rsp), %edi
jne 0x25db81
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::PlotHeatmap<double>(char const*, double const*, int, int, double, double, char const*, ImPlotPoint const&, ImPlotPoint const&)
|
void PlotHeatmap(const char* label_id, const T* values, int rows, int cols, double scale_min, double scale_max, const char* fmt, const ImPlotPoint& bounds_min, const ImPlotPoint& bounds_max) {
IM_ASSERT_USER_ERROR(scale_min != scale_max, "Scale values must be different!");
if (BeginItem(label_id)) {
if (FitThisFrame()) {
FitPoint(bounds_min);
FitPoint(bounds_max);
}
ImDrawList& DrawList = *GetPlotDrawList();
switch (GetCurrentScale()) {
case ImPlotScale_LinLin: RenderHeatmap(TransformerLinLin(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max); break;
case ImPlotScale_LogLin: RenderHeatmap(TransformerLogLin(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max); break;
case ImPlotScale_LinLog: RenderHeatmap(TransformerLinLog(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max); break;
case ImPlotScale_LogLog: RenderHeatmap(TransformerLogLog(), DrawList, values, rows, cols, scale_min, scale_max, fmt, bounds_min, bounds_max); break;
}
EndItem();
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm1, %xmm0
jne 0x25f3aa
jnp 0x25f4f4
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r13
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xebca0
testb %al, %al
je 0x25f4e5
movq 0x20b01f(%rip), %r15 # 0x46a3f0
movq (%r15), %rax
cmpb $0x1, 0x218(%rax)
jne 0x25f3ef
movq %rbx, %rdi
callq 0xe2280
movq 0x50(%rsp), %rdi
callq 0xe2280
callq 0xe6e40
movq (%r15), %rcx
movq 0x28(%rcx), %rdx
movslq 0x288(%rdx), %rdi
movl 0x158(%rcx,%rdi,4), %ecx
cmpq $0x3, %rcx
ja 0x25f4c1
leaq 0x14af0e(%rip), %rdx # 0x3aa328
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rax, %rsi
movq %r13, %rdx
movl %r12d, %ecx
movl %ebp, %r8d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %r9
pushq 0x50(%rsp)
pushq %rbx
callq 0xe76f0
jmp 0x25f4bd
movq %rax, %rsi
movq %r13, %rdx
movl %r12d, %ecx
movl %ebp, %r8d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %r9
pushq 0x50(%rsp)
pushq %rbx
callq 0xe3dd0
jmp 0x25f4bd
movq %rax, %rsi
movq %r13, %rdx
movl %r12d, %ecx
movl %ebp, %r8d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %r9
pushq 0x50(%rsp)
pushq %rbx
callq 0xe86a0
jmp 0x25f4bd
movq %rax, %rsi
movq %r13, %rdx
movl %r12d, %ecx
movl %ebp, %r8d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %r9
pushq 0x50(%rsp)
pushq %rbx
callq 0xe0320
addq $0x10, %rsp
movq (%r15), %rbx
callq 0xec9d0
leaq 0x578(%rbx), %rdi
callq 0xec570
movq 0x30(%rbx), %rax
movq %rax, 0x38(%rbx)
movq $0x0, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14b4e1(%rip), %rdi # 0x3aa9dc
leaq 0x14af31(%rip), %rsi # 0x3aa433
leaq 0x14ba4e(%rip), %rcx # 0x3aaf57
movl $0x6a8, %edx # imm = 0x6A8
callq 0xe3fd0
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::RenderMarkerPlus(ImDrawList&, ImVec2 const&, float, bool, unsigned int, bool, unsigned int, float)
|
inline void RenderMarkerPlus(ImDrawList& DrawList, const ImVec2& c, float s, bool /*outline*/, ImU32 col_outline, bool /*fill*/, ImU32 /*col_fill*/, float weight) {
ImVec2 marker[4] = {ImVec2(1, 0), ImVec2(0, -1), ImVec2(-1, 0), ImVec2(0, 1)};
TransformMarker(marker, 4, c, s);
DrawList.AddLine(marker[0], marker[2], col_outline, weight);
DrawList.AddLine(marker[1], marker[3], col_outline, weight);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps %xmm1, %xmm6
movss %xmm1, 0xc(%rsp)
movl %ecx, %ebx
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movaps 0x140aef(%rip), %xmm1 # 0x3a9810
movaps %xmm1, -0x8(%r15)
leaq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %r12
movaps 0x140ae9(%rip), %xmm2 # 0x3a9820
movaps %xmm2, -0x8(%r12)
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movss (%rsi), %xmm3
movss 0x4(%rsi), %xmm4
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
movaps %xmm1, %xmm5
shufps $0x88, %xmm2, %xmm5 # xmm5 = xmm5[0,2],xmm2[0,2]
shufps $0xdd, %xmm2, %xmm1 # xmm1 = xmm1[1,3],xmm2[1,3]
mulps %xmm0, %xmm5
addps %xmm3, %xmm5
mulps %xmm0, %xmm1
addps %xmm4, %xmm1
movaps %xmm5, %xmm0
unpckhps %xmm1, %xmm0 # xmm0 = xmm0[2],xmm1[2],xmm0[3],xmm1[3]
unpcklps %xmm1, %xmm5 # xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1]
movaps %xmm5, -0x18(%r12)
movaps %xmm0, -0x8(%r12)
leaq 0x10(%rsp), %rsi
movaps %xmm6, %xmm0
callq 0xe5ce0
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterYs<unsigned char>, ImPlot::TransformerLinLog>(ImPlot::GetterYs<unsigned char> const&, ImPlot::TransformerLinLog const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x200e66(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x2695a6
cmpb $0x1, 0x448(%r13)
jne 0x269856
movups 0x18(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x10(%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
movzbl (%rsi,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%r13,%rcx,8), %xmm0
movq 0x28(%r13), %rax
movq %rcx, %rdx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
movsd 0xa0(%rax,%rcx), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0]
cvtss2sd %xmm0, %xmm0
xorpd %xmm3, %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
shlq $0x4, %rdx
mulpd %xmm4, %xmm3
movapd 0x20(%rsp), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
cvtps2pd 0x164(%r13,%rdx), %xmm0
addpd %xmm3, %xmm4
movsd 0x18(%rax), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x48(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x269983
movl $0x1, %ebx
movups 0x18(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x10(%r15), %xmm0
movaps %xmm0, 0x70(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movapd %xmm0, 0x10(%rsp)
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
movzbl (%rsi,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%r12), %rbp
movq 0x28(%rbp), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
divsd 0x98(%rax,%rcx), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%rbp,%rcx,8), %xmm0
movq 0x28(%rbp), %rax
movq %rcx, %rdx
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
movsd 0xa0(%rax,%rcx), %xmm3
subsd %xmm2, %xmm3
movapd 0x70(%rsp), %xmm4
unpcklpd %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0]
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x10(%rsp), %xmm3
movlhps %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
mulpd %xmm4, %xmm3
shlq $0x4, %rdx
movapd 0x20(%rsp), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
addpd %xmm3, %xmm4
cvtps2pd 0x164(%rbp,%rdx), %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x40(%rsp)
movq 0x28(%r13), %rcx
movss 0x4c(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x26983e
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x26983e
movss 0x48(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x26983e
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x26983e
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x2696a4
jmp 0x269983
leaq 0x48(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movups 0x18(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x10(%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
movzbl (%rdi,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rax
divsd 0x1c0(%r13,%rax,8), %xmm0
movq 0x28(%r13), %rdx
movq %rax, %rcx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rax,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rax
movsd 0x98(%rdx,%rax), %xmm2
movsd 0xa0(%rdx,%rax), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0]
cvtss2sd %xmm0, %xmm0
xorpd %xmm3, %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
shlq $0x4, %rcx
mulpd %xmm4, %xmm3
movapd 0x20(%rsp), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
addpd %xmm3, %xmm4
cvtps2pd 0x164(%r13,%rcx), %xmm0
movsd 0x18(%rdx), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x38(%rsp), %rsi
callq 0xe0b80
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterYs<short>, ImPlot::TransformerLogLog>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rbp
leal 0x1(%r8), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x10(%rcx), %xmm0
addsd 0x18(%rcx), %xmm0
movq (%rcx), %rsi
movl 0x8(%rcx), %edi
addl 0x20(%rcx), %eax
movslq 0x24(%rcx), %rcx
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %rcx, %rax
movswl (%rsi,%rax), %eax
cvtsi2sd %eax, %xmm1
movsd %xmm1, (%rsp)
movq 0x1fd3a6(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%rbp), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%rbp), %rdx
movq 0x28(%r13), %rax
movq %rdx, %rcx
movapd 0x10(%rsp), %xmm3
movhpd 0x1c0(%r13,%rdx,8), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rdx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
divpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd 0x30(%rsp), %xmm5
movhpd 0xa0(%rax,%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm3, %xmm5
movapd %xmm3, %xmm4
mulpd %xmm5, %xmm0
cvtps2pd 0x164(%r13,%rcx), %xmm3
addpd %xmm4, %xmm0
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm0
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movsd 0x1c(%rbx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r12), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x26d2c9
movss 0x18(%rbx), %xmm3
movl 0x14(%rbx), %ecx
movsd (%r15), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x26d1da
sqrtss %xmm5, %xmm5
movss 0x115fb1(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0x115fa6(%rip), %xmm3 # 0x383188
movq 0x48(%r14), %rdx
movlps %xmm2, 0x8(%rdx)
movq 0x48(%r14), %rsi
movl %ecx, 0x10(%rsi)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rdx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rdx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%rsi)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%rsi)
movlps %xmm2, 0x1c(%rsi)
movq 0x48(%r14), %rdx
movl %ecx, 0x24(%rdx)
movss %xmm1, 0x28(%rdx)
movss %xmm4, 0x2c(%rdx)
movlps %xmm2, 0x30(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x38(%rdx)
movsd 0x1c(%rbx), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x4c(%rdx)
addq $0x50, %rdx
movq %rdx, 0x48(%r14)
movl 0x34(%r14), %ecx
movq 0x50(%r14), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%r14), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%r14), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%r14), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%r14)
addl $0x4, 0x34(%r14)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterYs<int>, ImPlot::TransformerLogLin>(ImPlot::GetterYs<int> const&, ImPlot::TransformerLogLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fab83(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x26f889
cmpb $0x1, 0x448(%r13)
jne 0x26fadc
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdl (%rsi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movslq (%r14), %rcx
movq %rcx, %rdx
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%r13,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x30(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x26fbde
movl $0x1, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
xorps %xmm1, %xmm1
cvtsi2sdl (%rsi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movsd 0x198(%rbp), %xmm2
movhpd 0x1a0(%rbp,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rcx, %rdx
shlq $0x4, %rcx
shlq $0x7, %rdx
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x28(%rsp)
movq 0x28(%r13), %rcx
movss 0x34(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x26fac4
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x26fac4
movss 0x30(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x26fac4
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x26fac4
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x26f95c
jmp 0x26fbde
leaq 0x30(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdl (%rdi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rdx
movupd 0x18(%rdx), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rax
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rax,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rax, %rcx
shlq $0x4, %rax
shlq $0x7, %rcx
cvtps2pd 0x164(%r13,%rax), %xmm3
movhpd 0x98(%rdx,%rcx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0xe91d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterYs<int>, ImPlot::TransformerLogLog>(ImPlot::GetterYs<int> const&, ImPlot::TransformerLogLog const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, 0x18(%rsp)
movss %xmm0, 0x1c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1fa3a7(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x270065
cmpb $0x1, 0x448(%r13)
jne 0x27038f
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdl (%rsi,%rax), %xmm1
movsd %xmm1, (%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x30(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rdx
movq 0x28(%r13), %rax
movq %rdx, %rcx
movapd 0x20(%rsp), %xmm2
movhpd 0x1c0(%r13,%rdx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movsd 0x198(%r13), %xmm0
movhpd 0x1a0(%r13,%rdx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x40(%rsp), %xmm5
movhpd 0xa0(%rax,%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtps2pd %xmm1, %xmm1
subpd %xmm3, %xmm5
movapd %xmm3, %xmm4
mulpd %xmm5, %xmm1
cvtps2pd 0x164(%r13,%rcx), %xmm3
addpd %xmm4, %xmm1
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x60(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x2704fb
movl $0x1, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
xorps %xmm1, %xmm1
cvtsi2sdl (%rsi,%rax), %xmm1
movsd %xmm1, (%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%rbp), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%rbp), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rdx
movq 0x28(%rbp), %rax
movq %rdx, %rcx
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x30(%rsp), %xmm2
movhpd 0x1c0(%rbp,%rdx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movsd 0x198(%rbp), %xmm0
movhpd 0x1a0(%rbp,%rdx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x40(%rsp), %xmm4
movhpd 0xa0(%rax,%rdx), %xmm4 # xmm4 = xmm4[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
cvtps2pd %xmm1, %xmm1
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x58(%rsp)
movq 0x28(%r13), %rcx
movss 0x64(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x270377
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x270377
movss 0x60(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x270377
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x270377
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movl 0x18(%rsp), %ecx
movss 0x1c(%rsp), %xmm0
callq 0xe5ce0
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x2701a6
jmp 0x2704fb
leaq 0x60(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdl (%rdi,%rax), %xmm1
movsd %xmm1, (%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
movq 0x28(%r13), %rdx
movq %rcx, %rax
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x30(%rsp), %xmm2
movhpd 0x1c0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movsd 0x198(%r13), %xmm0
movhpd 0x1a0(%r13,%rcx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rcx
shlq $0x4, %rax
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x40(%rsp), %xmm4
movhpd 0xa0(%rdx,%rcx), %xmm4 # xmm4 = xmm4[0],mem[0]
movsd 0x98(%rdx,%rcx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
cvtps2pd %xmm1, %xmm1
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
cvtps2pd 0x164(%r13,%rax), %xmm3
movsd 0x18(%rdx), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x50(%rsp), %rsi
callq 0xe0b30
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterYs<unsigned int>, ImPlot::TransformerLinLog>(ImPlot::GetterYs<unsigned int> const&, ImPlot::TransformerLinLog const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x38(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1f85c1(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x271e4b
cmpb $0x1, 0x448(%r13)
jne 0x2720fb
movups 0x18(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x10(%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
movl (%rsi,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%r13,%rcx,8), %xmm0
movq 0x28(%r13), %rax
movq %rcx, %rdx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
movsd 0xa0(%rax,%rcx), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0]
cvtss2sd %xmm0, %xmm0
xorpd %xmm3, %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
shlq $0x4, %rdx
mulpd %xmm4, %xmm3
movapd 0x20(%rsp), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
cvtps2pd 0x164(%r13,%rdx), %xmm0
addpd %xmm3, %xmm4
movsd 0x18(%rax), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x48(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x272228
movl $0x1, %ebx
movups 0x18(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x10(%r15), %xmm0
movaps %xmm0, 0x70(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movapd %xmm0, 0x10(%rsp)
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
movl (%rsi,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq (%r12), %rbp
movq 0x28(%rbp), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
divsd 0x98(%rax,%rcx), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%rbp,%rcx,8), %xmm0
movq 0x28(%rbp), %rax
movq %rcx, %rdx
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
movsd 0xa0(%rax,%rcx), %xmm3
subsd %xmm2, %xmm3
movapd 0x70(%rsp), %xmm4
unpcklpd %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0]
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x10(%rsp), %xmm3
movlhps %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
mulpd %xmm4, %xmm3
shlq $0x4, %rdx
movapd 0x20(%rsp), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
addpd %xmm3, %xmm4
cvtps2pd 0x164(%rbp,%rdx), %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x40(%rsp)
movq 0x28(%r13), %rcx
movss 0x4c(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x2720e3
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x2720e3
movss 0x48(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x2720e3
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x2720e3
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x271f49
jmp 0x272228
leaq 0x48(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movups 0x18(%r15), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x10(%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
movl (%rdi,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rax
divsd 0x1c0(%r13,%rax,8), %xmm0
movq 0x28(%r13), %rdx
movq %rax, %rcx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rax,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rax
movsd 0x98(%rdx,%rax), %xmm2
movsd 0xa0(%rdx,%rax), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0]
cvtss2sd %xmm0, %xmm0
xorpd %xmm3, %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
shlq $0x4, %rcx
mulpd %xmm4, %xmm3
movapd 0x20(%rsp), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
addpd %xmm3, %xmm4
cvtps2pd 0x164(%r13,%rcx), %xmm0
movsd 0x18(%rdx), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x38(%rsp), %rsi
callq 0xea530
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::LineStripRenderer<ImPlot::GetterYs<unsigned int>, ImPlot::TransformerLinLin>>(ImPlot::LineStripRenderer<ImPlot::GetterYs<unsigned int>, ImPlot::TransformerLinLin> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x272b1a
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x2, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x272a7c
testl %ebp, %ebp
je 0x272a68
leal (,%rbp,2), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x3fffffff, %eax # imm = 0x3FFFFFFF
cmpl %eax, %esi
movl $0x3fffffff, %edx # imm = 0x3FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x272a88
movl %ebp, %eax
subl %r13d, %eax
jae 0x272aed
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (%rdx,%rdx), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe1c20
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x272ab3
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x272a25
jmp 0x272aff
subl %r13d, %esi
cmpl $-0x5, %edi
jbe 0x272af9
movl %eax, %ebp
jmp 0x272ae3
movl %esi, 0x4(%rsp)
jmp 0x272aa9
testl %ebp, %ebp
je 0x272b1a
leal (,%rbp,2), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::LineStripRenderer<ImPlot::GetterYs<unsigned int>, ImPlot::TransformerLinLog>>(ImPlot::LineStripRenderer<ImPlot::GetterYs<unsigned int>, ImPlot::TransformerLinLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x27324a
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x2, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x2731ac
testl %ebp, %ebp
je 0x273198
leal (,%rbp,2), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x3fffffff, %eax # imm = 0x3FFFFFFF
cmpl %eax, %esi
movl $0x3fffffff, %edx # imm = 0x3FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x2731b8
movl %ebp, %eax
subl %r13d, %eax
jae 0x27321d
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (%rdx,%rdx), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe2560
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x2731e3
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x273155
jmp 0x27322f
subl %r13d, %esi
cmpl $-0x5, %edi
jbe 0x273229
movl %eax, %ebp
jmp 0x273213
movl %esi, 0x4(%rsp)
jmp 0x2731d9
testl %ebp, %ebp
je 0x27324a
leal (,%rbp,2), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::LineStripRenderer<ImPlot::GetterYs<long long>, ImPlot::TransformerLinLog>>(ImPlot::LineStripRenderer<ImPlot::GetterYs<long long>, ImPlot::TransformerLinLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x275460
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x2, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x2753c2
testl %ebp, %ebp
je 0x2753ae
leal (,%rbp,2), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x3fffffff, %eax # imm = 0x3FFFFFFF
cmpl %eax, %esi
movl $0x3fffffff, %edx # imm = 0x3FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x2753ce
movl %ebp, %eax
subl %r13d, %eax
jae 0x275433
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (%rdx,%rdx), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xea6d0
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x2753f9
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x27536b
jmp 0x275445
subl %r13d, %esi
cmpl $-0x5, %edi
jbe 0x27543f
movl %eax, %ebp
jmp 0x275429
movl %esi, 0x4(%rsp)
jmp 0x2753ef
testl %ebp, %ebp
je 0x275460
leal (,%rbp,2), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterYs<long long>, ImPlot::TransformerLogLog>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
leal 0x1(%r8), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x10(%rcx), %xmm0
addsd 0x18(%rcx), %xmm0
movq 0x8(%rdi), %rbp
movq (%rcx), %rsi
movl 0x8(%rcx), %edi
movslq 0x24(%rcx), %r8
addl 0x20(%rcx), %eax
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdq (%rsi,%rax), %xmm1
movsd %xmm1, (%rsp)
movq 0x1f4b24(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%rbp), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%rbp), %rdx
movq 0x28(%r13), %rax
movq %rdx, %rcx
movapd 0x10(%rsp), %xmm3
movhpd 0x1c0(%r13,%rdx,8), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rdx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
divpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd 0x30(%rsp), %xmm5
movhpd 0xa0(%rax,%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm3, %xmm5
movapd %xmm3, %xmm4
mulpd %xmm5, %xmm0
cvtps2pd 0x164(%r13,%rcx), %xmm3
addpd %xmm4, %xmm0
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm0
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movsd 0x1c(%rbx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r12), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x275b4b
movss 0x18(%rbx), %xmm3
movl 0x14(%rbx), %ecx
movsd (%r15), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x275a5c
sqrtss %xmm5, %xmm5
movss 0x10d72f(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0x10d724(%rip), %xmm3 # 0x383188
movq 0x48(%r14), %rdx
movlps %xmm2, 0x8(%rdx)
movq 0x48(%r14), %rsi
movl %ecx, 0x10(%rsi)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rdx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rdx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%rsi)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%rsi)
movlps %xmm2, 0x1c(%rsi)
movq 0x48(%r14), %rdx
movl %ecx, 0x24(%rdx)
movss %xmm1, 0x28(%rdx)
movss %xmm4, 0x2c(%rdx)
movlps %xmm2, 0x30(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x38(%rdx)
movsd 0x1c(%rbx), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x4c(%rdx)
addq $0x50, %rdx
movq %rdx, 0x48(%r14)
movl 0x34(%r14), %ecx
movq 0x50(%r14), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%r14), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%r14), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%r14), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%r14)
addl $0x4, 0x34(%r14)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterYs<float>, ImPlot::TransformerLogLin>(ImPlot::GetterYs<float> const&, ImPlot::TransformerLogLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1f2168(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x2782a4
cmpb $0x1, 0x448(%r13)
jne 0x2784f5
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
cvtss2sd (%rsi,%rax), %xmm1
movaps %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movslq (%r14), %rcx
movq %rcx, %rdx
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%r13,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x30(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x2785f6
movl $0x1, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
xorps %xmm1, %xmm1
cvtss2sd (%rsi,%rax), %xmm1
movaps %xmm1, 0x10(%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movsd 0x198(%rbp), %xmm2
movhpd 0x1a0(%rbp,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rcx, %rdx
shlq $0x4, %rcx
shlq $0x7, %rdx
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x28(%rsp)
movq 0x28(%r13), %rcx
movss 0x34(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x2784dd
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x2784dd
movss 0x30(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x2784dd
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x2784dd
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x278376
jmp 0x2785f6
leaq 0x30(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
cvtss2sd (%rdi,%rax), %xmm1
movaps %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rdx
movupd 0x18(%rdx), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rax
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rax,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rax, %rcx
shlq $0x4, %rax
shlq $0x7, %rcx
cvtps2pd 0x164(%r13,%rax), %xmm3
movhpd 0x98(%rdx,%rcx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0xeb6e0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderMarkers<ImPlot::TransformerLogLog, ImPlot::GetterYs<float>>(ImPlot::GetterYs<float>, ImPlot::TransformerLogLog, ImDrawList&, int, float, bool, unsigned int, float, bool, unsigned int)
|
inline void RenderMarkers(Getter getter, Transformer transformer, ImDrawList& DrawList, ImPlotMarker marker, float size, bool rend_mk_line, ImU32 col_mk_line, float weight, bool rend_mk_fill, ImU32 col_mk_fill) {
static void (*marker_table[ImPlotMarker_COUNT])(ImDrawList&, const ImVec2&, float s, bool, ImU32, bool, ImU32, float) = {
RenderMarkerCircle,
RenderMarkerSquare,
RenderMarkerDiamond ,
RenderMarkerUp ,
RenderMarkerDown ,
RenderMarkerLeft,
RenderMarkerRight,
RenderMarkerCross,
RenderMarkerPlus,
RenderMarkerAsterisk
};
ImPlotContext& gp = *GImPlot;
for (int i = 0; i < getter.Count; ++i) {
ImVec2 c = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Contains(c))
marker_table[marker](DrawList, c, size, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, weight);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movss %xmm1, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rsi, 0x38(%rsp)
movl 0xf8(%rsp), %ebp
testl %ebp, %ebp
jle 0x2791c9
leaq 0xf0(%rsp), %rax
movq 0x1f1486(%rip), %rsi # 0x46a3f0
movq (%rsi), %rsi
movq %rsi, 0x68(%rsp)
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x58(%rsp)
movq (%rax), %rsi
movq %rsi, 0x50(%rsp)
movl 0x20(%rax), %esi
movq %rsi, 0x48(%rsp)
movslq 0x24(%rax), %rax
movq %rax, 0x40(%rsp)
movslq %edi, %r14
movslq %edx, %rax
movq %rax, 0x30(%rsp)
xorl %ebx, %ebx
xorpd %xmm1, %xmm1
movq %r14, %r13
shlq $0x7, %r13
movq %r14, %r15
shlq $0x4, %r15
movzbl %cl, %eax
movl %eax, 0x10(%rsp)
movzbl %r9b, %eax
movl %eax, 0xc(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm1, 0x70(%rsp)
mulsd %xmm1, %xmm0
addsd 0x60(%rsp), %xmm0
movq 0x48(%rsp), %rax
addl %ebx, %eax
cltd
idivl %ebp
leal (%rdx,%rbp), %eax
cltd
idivl %ebp
movslq %edx, %rax
imulq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%rax), %xmm1
movsd %xmm1, 0x20(%rsp)
movq 0x1f13d8(%rip), %rax # 0x46a3f0
movq (%rax), %r12
movq 0x28(%r12), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r12), %rax
movsd 0x20(%rsp), %xmm1
divsd 0x98(%rax,%r13), %xmm1
movapd %xmm0, 0x80(%rsp)
movsd 0x1b8(%r12), %xmm0
movaps %xmm0, 0x90(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0xa0(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r12), %rax
movapd 0x80(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x90(%rsp), %xmm0
movhpd 0x1c0(%r12,%r14,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0xa0(%rsp), %xmm3
movhpd 0xa0(%rax,%r13), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%r13), %xmm1
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
cvtps2pd 0x164(%r12,%r15), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r12), %xmm1
movhpd 0x1a0(%r12,%r14,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x78(%rsp)
movq 0x68(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x27914d
movsd 0x70(%rsp), %xmm1
addsd 0x10bfb7(%rip), %xmm1 # 0x3850f8
incl %ebx
cmpl %ebx, %ebp
jne 0x278fcf
jmp 0x2791c9
movsd 0x2bc(%rax), %xmm1
movaps %xmm1, %xmm2
shufps $0xe1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[2,3]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
ucomiss %xmm0, %xmm1
seta %cl
cmpleps %xmm0, %xmm2
pextrw $0x2, %xmm2, %edx
testb $0x1, %dl
je 0x279133
testb %cl, %cl
je 0x279133
movss 0x2c4(%rax), %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm0, %xmm1
jbe 0x279133
movq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movss 0x14(%rsp), %xmm0
movl 0x10(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x118(%rsp), %r9d
movss 0x1c(%rsp), %xmm1
movq 0x30(%rsp), %rax
movq 0x1f6b28(%rip), %r10 # 0x46fce8
callq *(%r10,%rax,8)
jmp 0x279133
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterYs<float>, ImPlot::TransformerLinLin>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %rbx
movq %rdx, %r9
movq (%rdi), %rdx
movq 0x8(%rdi), %r10
leal 0x1(%r8), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x10(%rdx), %xmm0
addsd 0x18(%rdx), %xmm0
movq (%rdx), %r8
movl 0x8(%rdx), %r11d
addl 0x20(%rdx), %eax
movslq 0x24(%rdx), %rbx
cltd
idivl %r11d
leal (%rdx,%r11), %eax
cltd
idivl %r11d
movslq %edx, %rax
imulq %rbx, %rax
cvtss2sd (%r8,%rax), %xmm1
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movq 0x1f1089(%rip), %rax # 0x46a3f0
movq (%rax), %rax
movslq (%r10), %rdx
movq %rdx, %r8
movsd 0x198(%rax), %xmm1
movhpd 0x1a0(%rax,%rdx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x4, %rdx
movq 0x28(%rax), %r10
shlq $0x7, %r8
cvtps2pd 0x164(%rax,%rdx), %xmm2
movsd 0x18(%r10), %xmm3
movhpd 0x98(%r10,%r8), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm0
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movsd 0x1c(%rdi), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r9), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x279538
movss 0x18(%rdi), %xmm3
movl 0x14(%rdi), %edx
movsd (%rcx), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x27944a
sqrtss %xmm5, %xmm5
movss 0x109d41(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0x109d36(%rip), %xmm3 # 0x383188
movq 0x48(%rsi), %rcx
movlps %xmm2, 0x8(%rcx)
movq 0x48(%rsi), %r8
movl %edx, 0x10(%r8)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rcx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rcx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%r8)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%r8)
movlps %xmm2, 0x1c(%r8)
movq 0x48(%rsi), %rcx
movl %edx, 0x24(%rcx)
movss %xmm1, 0x28(%rcx)
movss %xmm4, 0x2c(%rcx)
movlps %xmm2, 0x30(%rcx)
movq 0x48(%rsi), %rcx
movl %edx, 0x38(%rcx)
movsd 0x1c(%rdi), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rcx)
movq 0x48(%rsi), %rcx
movl %edx, 0x4c(%rcx)
addq $0x50, %rcx
movq %rcx, 0x48(%rsi)
movl 0x34(%rsi), %ecx
movq 0x50(%rsi), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%rsi), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%rsi), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%rsi), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%rsi)
addl $0x4, 0x34(%rsi)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rdi)
popq %rbx
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterXsYs<signed char>, ImPlot::TransformerLinLog>(ImPlot::GetterXsYs<signed char> const&, ImPlot::TransformerLinLog const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1ed99e(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x27ca6e
cmpb $0x1, 0x448(%r13)
jne 0x27ccef
movl 0x10(%r15), %esi
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movsbl (%rdx,%rax), %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x8(%r15), %rdx
movsbl (%rdx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%r13,%rcx,8), %xmm0
movq 0x28(%r13), %rax
movq %rcx, %rdx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
cvtsd2ss %xmm0, %xmm0
movsd 0xa0(%rax,%rcx), %xmm3
subsd %xmm2, %xmm3
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
shlq $0x4, %rdx
movsd 0x18(%rax), %xmm0
unpcklpd %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0]
cvtps2pd 0x164(%r13,%rdx), %xmm2
subpd %xmm0, %xmm3
mulpd %xmm3, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x30(%rsp)
movl 0x10(%r15), %ecx
cmpl $0x2, %ecx
jl 0x27ce0b
movl $0x1, %ebx
movslq 0x18(%r15), %rsi
movl 0x14(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
movsbl (%rcx,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movapd %xmm0, 0x10(%rsp)
movsbl (%rdx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq (%r12), %rbp
movq 0x28(%rbp), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
divsd 0x98(%rax,%rcx), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%rbp,%rcx,8), %xmm0
movq 0x28(%rbp), %rax
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rcx, %rdx
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
movsd 0xa0(%rax,%rcx), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0]
shlq $0x4, %rdx
cvtps2pd 0x164(%rbp,%rdx), %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x28(%rsp)
movq 0x28(%r13), %rcx
movss 0x34(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x27ccd7
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x27ccd7
movss 0x30(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x27ccd7
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x27ccd7
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
incl %ebx
movl 0x10(%r15), %ecx
cmpl %ecx, %ebx
jl 0x27cb5b
jmp 0x27ce0b
leaq 0x30(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x10(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movsbl (%rdx,%rax), %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x8(%r15), %rdx
movsbl (%rdx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rax
divsd 0x1c0(%r13,%rax,8), %xmm0
movq 0x28(%r13), %rdx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rax,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rax, %rcx
shlq $0x7, %rax
movsd 0x98(%rdx,%rax), %xmm2
movsd 0xa0(%rdx,%rax), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%r13,%rcx), %xmm0
movsd 0x18(%rdx), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0xe82c0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterXsYs<unsigned char>, ImPlot::TransformerLinLin>(ImPlot::GetterXsYs<unsigned char> const&, ImPlot::TransformerLinLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r15
movq 0x1ebedd(%rip), %r10 # 0x46a3f0
movq (%r10), %r12
movq 0x28(%r12), %r9
testb $0x10, 0x5(%r9)
jne 0x27e531
cmpb $0x1, 0x448(%r12)
jne 0x27e75a
movl 0x10(%r15), %esi
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rdi
movzbl (%rdx,%rax), %edx
movzbl (%rdi,%rax), %eax
movslq (%r14), %rdi
movq %rdi, %r8
movsd 0x1a0(%r12,%rdi,8), %xmm4
shlq $0x4, %rdi
movd %eax, %xmm1
pinsrw $0x2, %edx, %xmm1
cvtdq2pd %xmm1, %xmm1
cvtps2pd 0x164(%r12,%rdi), %xmm2
shlq $0x7, %r8
movsd 0x98(%r9,%r8), %xmm3
movhpd 0x18(%r9), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm1
shufpd $0x1, %xmm2, %xmm2 # xmm2 = xmm2[1,0]
movhpd 0x198(%r12), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm1, %xmm4
addpd %xmm2, %xmm4
cvtpd2ps %xmm4, %xmm5
movapd %xmm5, %xmm1
shufps $0xe1, %xmm5, %xmm1 # xmm1 = xmm1[1,0],xmm5[2,3]
movlps %xmm1, 0x20(%rsp)
cmpl $0x2, %esi
jl 0x27e80e
movl $0x1, %r13d
movq %r12, %rbx
movss %xmm0, 0xc(%rsp)
movq %r12, 0x18(%rsp)
movslq 0x18(%r15), %rdi
movl 0x14(%r15), %eax
addl %r13d, %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rdi
movzbl (%rdx,%rax), %edx
movzbl (%rdi,%rax), %eax
movslq (%r14), %rdi
movsd 0x198(%rbx), %xmm1
movhpd 0x1a0(%rbx,%rdi,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rdi, %r8
shlq $0x4, %rdi
movq 0x28(%rbx), %r9
shlq $0x7, %r8
movd %edx, %xmm2
pinsrw $0x2, %eax, %xmm2
cvtdq2pd %xmm2, %xmm2
cvtps2pd 0x164(%rbx,%rdi), %xmm3
movsd 0x18(%r9), %xmm4
movhpd 0x98(%r9,%r8), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm2
mulpd %xmm2, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm1
movlpd %xmm1, 0x10(%rsp)
movq 0x28(%r12), %rdx
movq %xmm1, %rax
movapd %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2 # xmm2 = xmm2[1,1],xmm1[1,1]
movaps %xmm5, %xmm3
minss %xmm2, %xmm3
movss 0x2c4(%rdx), %xmm4
ucomiss %xmm3, %xmm4
shufps $0x51, %xmm1, %xmm1 # xmm1 = xmm1[1,0,1,1]
jbe 0x27e741
movaps %xmm2, %xmm3
cmpless %xmm5, %xmm3
movaps %xmm3, %xmm4
andps %xmm5, %xmm4
andnps %xmm2, %xmm3
orps %xmm4, %xmm3
ucomiss 0x2bc(%rdx), %xmm3
jbe 0x27e741
movd %eax, %xmm2
shufps $0x55, %xmm5, %xmm5 # xmm5 = xmm5[1,1,1,1]
movaps %xmm5, %xmm3
minss %xmm2, %xmm3
movss 0x2c0(%rdx), %xmm4
ucomiss %xmm3, %xmm4
jbe 0x27e741
movaps %xmm2, %xmm3
cmpless %xmm5, %xmm3
movaps %xmm3, %xmm4
andnps %xmm2, %xmm4
andps %xmm5, %xmm3
orps %xmm4, %xmm3
ucomiss 0x2b8(%rdx), %xmm3
jbe 0x27e741
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %r12
movl %ecx, %r14d
movq %r10, %rbx
callq 0xe5ce0
movq %rbx, %r10
movl %r14d, %ecx
movq %r12, %r14
movq 0x18(%rsp), %r12
movss 0xc(%rsp), %xmm0
movq (%rbx), %rbx
movq 0x10(%rsp), %rax
movl 0x10(%r15), %esi
movq %rax, %rdx
shrq $0x20, %rdx
movd %eax, %xmm2
movd %edx, %xmm1
punpckldq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movq %rax, 0x20(%rsp)
incl %r13d
movaps %xmm1, %xmm5
cmpl %esi, %r13d
jl 0x27e5e3
jmp 0x27e80e
leaq 0x20(%rsp), %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movl 0x10(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movss %xmm0, 0x18(%rdi)
movl 0x14(%r15), %eax
movslq 0x18(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movzbl (%rdx,%rax), %edx
movzbl (%rsi,%rax), %eax
movslq (%r14), %rsi
movq %rsi, %r8
movsd 0x198(%r12), %xmm0
movhpd 0x1a0(%r12,%rsi,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x4, %rsi
shlq $0x7, %r8
movd %edx, %xmm1
pinsrw $0x2, %eax, %xmm1
cvtdq2pd %xmm1, %xmm1
movsd 0x18(%r9), %xmm2
movhpd 0x98(%r9,%r8), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm1
cvtps2pd 0x164(%r12,%rsi), %xmm2
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x1c(%rdi)
addq $0x2b8, %r9 # imm = 0x2B8
movq %rbp, %rsi
movq %r9, %rdx
callq 0xe1090
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderMarkers<ImPlot::TransformerLogLog, ImPlot::GetterXsYs<short>>(ImPlot::GetterXsYs<short>, ImPlot::TransformerLogLog, ImDrawList&, int, float, bool, unsigned int, float, bool, unsigned int)
|
inline void RenderMarkers(Getter getter, Transformer transformer, ImDrawList& DrawList, ImPlotMarker marker, float size, bool rend_mk_line, ImU32 col_mk_line, float weight, bool rend_mk_fill, ImU32 col_mk_fill) {
static void (*marker_table[ImPlotMarker_COUNT])(ImDrawList&, const ImVec2&, float s, bool, ImU32, bool, ImU32, float) = {
RenderMarkerCircle,
RenderMarkerSquare,
RenderMarkerDiamond ,
RenderMarkerUp ,
RenderMarkerDown ,
RenderMarkerLeft,
RenderMarkerRight,
RenderMarkerCross,
RenderMarkerPlus,
RenderMarkerAsterisk
};
ImPlotContext& gp = *GImPlot;
for (int i = 0; i < getter.Count; ++i) {
ImVec2 c = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Contains(c))
marker_table[marker](DrawList, c, size, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, weight);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movss %xmm1, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rsi, 0x38(%rsp)
movl 0xf0(%rsp), %ebp
testl %ebp, %ebp
jle 0x2818ca
leaq 0xe0(%rsp), %rax
movq 0x1e8d59(%rip), %rsi # 0x46a3f0
movq (%rsi), %rsi
movq %rsi, 0x60(%rsp)
movq (%rax), %rsi
movq %rsi, 0x58(%rsp)
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movl 0x14(%rax), %esi
movq %rsi, 0x48(%rsp)
movslq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movslq %edi, %r15
movslq %edx, %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
movq %r15, %rbx
shlq $0x7, %rbx
movq %r15, %r12
shlq $0x4, %r12
movzbl %cl, %eax
movl %eax, 0x10(%rsp)
movzbl %r9b, %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rax
addl %r14d, %eax
cltd
idivl %ebp
leal (%rdx,%rbp), %eax
cltd
idivl %ebp
movslq %edx, %rax
imulq 0x40(%rsp), %rax
movq 0x58(%rsp), %rcx
movswl (%rcx,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movq 0x50(%rsp), %rcx
movswl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm1, 0x20(%rsp)
movq 0x1e8cbd(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movsd 0x20(%rsp), %xmm1
divsd 0x98(%rax,%rbx), %xmm1
movapd %xmm0, 0x70(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x80(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movapd 0x70(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x80(%rsp), %xmm0
movhpd 0x1c0(%r13,%r15,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x90(%rsp), %xmm3
movhpd 0xa0(%rax,%rbx), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%rbx), %xmm1
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
cvtps2pd 0x164(%r13,%r12), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%r15,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x28184e
incl %r14d
cmpl %r14d, %ebp
jne 0x2816ec
jmp 0x2818ca
movsd 0x2bc(%rax), %xmm1
movaps %xmm1, %xmm2
shufps $0xe1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[2,3]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
ucomiss %xmm0, %xmm1
seta %cl
cmpleps %xmm0, %xmm2
pextrw $0x2, %xmm2, %edx
testb $0x1, %dl
je 0x281840
testb %cl, %cl
je 0x281840
movss 0x2c4(%rax), %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm0, %xmm1
jbe 0x281840
movq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movss 0x14(%rsp), %xmm0
movl 0x10(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x100(%rsp), %r9d
movss 0x1c(%rsp), %xmm1
movq 0x30(%rsp), %rax
movq 0x1ed7f7(%rip), %r10 # 0x46f0b8
callq *(%r10,%rax,8)
jmp 0x281840
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterXsYs<short>, ImPlot::TransformerLinLin>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %r14
pushq %rbx
movq %rdx, %r9
movq (%rdi), %r11
movq 0x8(%rdi), %rbx
movl 0x10(%r11), %r10d
movl 0x14(%r11), %eax
movslq 0x18(%r11), %r14
addl %r8d, %eax
incl %eax
cltd
idivl %r10d
leal (%rdx,%r10), %eax
cltd
idivl %r10d
movslq %edx, %rax
imulq %r14, %rax
movq (%r11), %r10
movq 0x8(%r11), %r8
movq 0x1e8999(%rip), %rdx # 0x46a3f0
movq (%rdx), %rdx
movslq (%rbx), %r11
movq %r11, %rbx
movsd 0x198(%rdx), %xmm0
movhpd 0x1a0(%rdx,%r11,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x4, %r11
movq 0x28(%rdx), %r14
pxor %xmm1, %xmm1
pinsrw $0x1, (%r10,%rax), %xmm1
shlq $0x7, %rbx
pinsrw $0x3, (%r8,%rax), %xmm1
psrad $0x10, %xmm1
cvtdq2pd %xmm1, %xmm1
cvtps2pd 0x164(%rdx,%r11), %xmm2
movsd 0x18(%r14), %xmm3
movhpd 0x98(%r14,%rbx), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movsd 0x1c(%rdi), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r9), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x281c45
movss 0x18(%rdi), %xmm3
movl 0x14(%rdi), %edx
movsd (%rcx), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x281b57
sqrtss %xmm5, %xmm5
movss 0x101634(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0x101629(%rip), %xmm3 # 0x383188
movq 0x48(%rsi), %rcx
movlps %xmm2, 0x8(%rcx)
movq 0x48(%rsi), %r8
movl %edx, 0x10(%r8)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rcx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rcx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%r8)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%r8)
movlps %xmm2, 0x1c(%r8)
movq 0x48(%rsi), %rcx
movl %edx, 0x24(%rcx)
movss %xmm1, 0x28(%rcx)
movss %xmm4, 0x2c(%rcx)
movlps %xmm2, 0x30(%rcx)
movq 0x48(%rsi), %rcx
movl %edx, 0x38(%rcx)
movsd 0x1c(%rdi), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rcx)
movq 0x48(%rsi), %rcx
movl %edx, 0x4c(%rcx)
addq $0x50, %rcx
movq %rcx, 0x48(%rsi)
movl 0x34(%rsi), %ecx
movq 0x50(%rsi), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%rsi), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%rsi), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%rsi), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%rsi)
addl $0x4, 0x34(%rsi)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rdi)
popq %rbx
popq %r14
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::LineStripRenderer<ImPlot::GetterXsYs<short>, ImPlot::TransformerLogLog>>(ImPlot::LineStripRenderer<ImPlot::GetterXsYs<short>, ImPlot::TransformerLogLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x282522
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x2, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x282484
testl %ebp, %ebp
je 0x282470
leal (,%rbp,2), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x3fffffff, %eax # imm = 0x3FFFFFFF
cmpl %eax, %esi
movl $0x3fffffff, %edx # imm = 0x3FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x282490
movl %ebp, %eax
subl %r13d, %eax
jae 0x2824f5
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (%rdx,%rdx), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe4c90
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x2824bb
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x28242d
jmp 0x282507
subl %r13d, %esi
cmpl $-0x5, %edi
jbe 0x282501
movl %eax, %ebp
jmp 0x2824eb
movl %esi, 0x4(%rsp)
jmp 0x2824b1
testl %ebp, %ebp
je 0x282522
leal (,%rbp,2), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderMarkers<ImPlot::TransformerLogLog, ImPlot::GetterXsYs<unsigned short>>(ImPlot::GetterXsYs<unsigned short>, ImPlot::TransformerLogLog, ImDrawList&, int, float, bool, unsigned int, float, bool, unsigned int)
|
inline void RenderMarkers(Getter getter, Transformer transformer, ImDrawList& DrawList, ImPlotMarker marker, float size, bool rend_mk_line, ImU32 col_mk_line, float weight, bool rend_mk_fill, ImU32 col_mk_fill) {
static void (*marker_table[ImPlotMarker_COUNT])(ImDrawList&, const ImVec2&, float s, bool, ImU32, bool, ImU32, float) = {
RenderMarkerCircle,
RenderMarkerSquare,
RenderMarkerDiamond ,
RenderMarkerUp ,
RenderMarkerDown ,
RenderMarkerLeft,
RenderMarkerRight,
RenderMarkerCross,
RenderMarkerPlus,
RenderMarkerAsterisk
};
ImPlotContext& gp = *GImPlot;
for (int i = 0; i < getter.Count; ++i) {
ImVec2 c = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Contains(c))
marker_table[marker](DrawList, c, size, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, weight);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movss %xmm1, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rsi, 0x38(%rsp)
movl 0xf0(%rsp), %ebp
testl %ebp, %ebp
jle 0x283a59
leaq 0xe0(%rsp), %rax
movq 0x1e6bca(%rip), %rsi # 0x46a3f0
movq (%rsi), %rsi
movq %rsi, 0x60(%rsp)
movq (%rax), %rsi
movq %rsi, 0x58(%rsp)
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movl 0x14(%rax), %esi
movq %rsi, 0x48(%rsp)
movslq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movslq %edi, %r15
movslq %edx, %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
movq %r15, %rbx
shlq $0x7, %rbx
movq %r15, %r12
shlq $0x4, %r12
movzbl %cl, %eax
movl %eax, 0x10(%rsp)
movzbl %r9b, %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rax
addl %r14d, %eax
cltd
idivl %ebp
leal (%rdx,%rbp), %eax
cltd
idivl %ebp
movslq %edx, %rax
imulq 0x40(%rsp), %rax
movq 0x58(%rsp), %rcx
movzwl (%rcx,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movq 0x50(%rsp), %rcx
movzwl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm1, 0x20(%rsp)
movq 0x1e6b2e(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movsd 0x20(%rsp), %xmm1
divsd 0x98(%rax,%rbx), %xmm1
movapd %xmm0, 0x70(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x80(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movapd 0x70(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x80(%rsp), %xmm0
movhpd 0x1c0(%r13,%r15,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x90(%rsp), %xmm3
movhpd 0xa0(%rax,%rbx), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%rbx), %xmm1
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
cvtps2pd 0x164(%r13,%r12), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%r15,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x2839dd
incl %r14d
cmpl %r14d, %ebp
jne 0x28387b
jmp 0x283a59
movsd 0x2bc(%rax), %xmm1
movaps %xmm1, %xmm2
shufps $0xe1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[2,3]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
ucomiss %xmm0, %xmm1
seta %cl
cmpleps %xmm0, %xmm2
pextrw $0x2, %xmm2, %edx
testb $0x1, %dl
je 0x2839cf
testb %cl, %cl
je 0x2839cf
movss 0x2c4(%rax), %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm0, %xmm1
jbe 0x2839cf
movq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movss 0x14(%rsp), %xmm0
movl 0x10(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x100(%rsp), %r9d
movss 0x1c(%rsp), %xmm1
movq 0x30(%rsp), %rax
movq 0x1ebe30(%rip), %r10 # 0x46f880
callq *(%r10,%rax,8)
jmp 0x2839cf
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterXsYs<unsigned short>, ImPlot::TransformerLinLin>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %r14
pushq %rbx
movq %rdx, %r9
movq (%rdi), %r10
movq 0x8(%rdi), %r11
movl 0x10(%r10), %ebx
movl 0x14(%r10), %eax
movslq 0x18(%r10), %r14
addl %r8d, %eax
incl %eax
cltd
idivl %ebx
leal (%rdx,%rbx), %eax
cltd
idivl %ebx
movslq %edx, %rax
imulq %r14, %rax
movq (%r10), %rdx
movq 0x8(%r10), %r8
movzwl (%rdx,%rax), %edx
movq 0x1e6808(%rip), %r10 # 0x46a3f0
movq (%r10), %r10
movslq (%r11), %r11
movsd 0x198(%r10), %xmm0
movhpd 0x1a0(%r10,%r11,8), %xmm0 # xmm0 = xmm0[0],mem[0]
movq %r11, %rbx
shlq $0x4, %r11
movq 0x28(%r10), %r14
shlq $0x7, %rbx
movd %edx, %xmm1
pinsrw $0x2, (%r8,%rax), %xmm1
cvtdq2pd %xmm1, %xmm1
cvtps2pd 0x164(%r10,%r11), %xmm2
movsd 0x18(%r14), %xmm3
movhpd 0x98(%r14,%rbx), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movsd 0x1c(%rdi), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r9), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x283dcb
movss 0x18(%rdi), %xmm3
movl 0x14(%rdi), %edx
movsd (%rcx), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x283cdd
sqrtss %xmm5, %xmm5
movss 0xff4ae(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0xff4a3(%rip), %xmm3 # 0x383188
movq 0x48(%rsi), %rcx
movlps %xmm2, 0x8(%rcx)
movq 0x48(%rsi), %r8
movl %edx, 0x10(%r8)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rcx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rcx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%r8)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%r8)
movlps %xmm2, 0x1c(%r8)
movq 0x48(%rsi), %rcx
movl %edx, 0x24(%rcx)
movss %xmm1, 0x28(%rcx)
movss %xmm4, 0x2c(%rcx)
movlps %xmm2, 0x30(%rcx)
movq 0x48(%rsi), %rcx
movl %edx, 0x38(%rcx)
movsd 0x1c(%rdi), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rcx)
movq 0x48(%rsi), %rcx
movl %edx, 0x4c(%rcx)
addq $0x50, %rcx
movq %rcx, 0x48(%rsi)
movl 0x34(%rsi), %ecx
movq 0x50(%rsi), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%rsi), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%rsi), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%rsi), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%rsi)
addl $0x4, 0x34(%rsi)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rdi)
popq %rbx
popq %r14
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::LineStripRenderer<ImPlot::GetterXsYs<int>, ImPlot::TransformerLinLog>>(ImPlot::LineStripRenderer<ImPlot::GetterXsYs<int>, ImPlot::TransformerLinLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x28640d
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x2, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x28636f
testl %ebp, %ebp
je 0x28635b
leal (,%rbp,2), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x3fffffff, %eax # imm = 0x3FFFFFFF
cmpl %eax, %esi
movl $0x3fffffff, %edx # imm = 0x3FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x28637b
movl %ebp, %eax
subl %r13d, %eax
jae 0x2863e0
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (%rdx,%rdx), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe2c60
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x2863a6
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x286318
jmp 0x2863f2
subl %r13d, %esi
cmpl $-0x5, %edi
jbe 0x2863ec
movl %eax, %ebp
jmp 0x2863d6
movl %esi, 0x4(%rsp)
jmp 0x28639c
testl %ebp, %ebp
je 0x28640d
leal (,%rbp,2), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterXsYs<int>, ImPlot::TransformerLogLog>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rbp
movl 0x10(%rcx), %esi
movl 0x14(%rcx), %eax
movslq 0x18(%rcx), %rdi
addl %r8d, %eax
incl %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%rcx), %rdx
cvtsi2sdl (%rdx,%rax), %xmm0
movq 0x8(%rcx), %rcx
cvtsi2sdl (%rcx,%rax), %xmm1
movsd %xmm1, (%rsp)
movq 0x1e3b9d(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%rbp), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%rbp), %rdx
movq 0x28(%r13), %rax
movq %rdx, %rcx
movapd 0x10(%rsp), %xmm3
movhpd 0x1c0(%r13,%rdx,8), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rdx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
divpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd 0x30(%rsp), %xmm5
movhpd 0xa0(%rax,%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm3, %xmm5
movapd %xmm3, %xmm4
mulpd %xmm5, %xmm0
cvtps2pd 0x164(%r13,%rcx), %xmm3
addpd %xmm4, %xmm0
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm0
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movsd 0x1c(%rbx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r12), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x286ad2
movss 0x18(%rbx), %xmm3
movl 0x14(%rbx), %ecx
movsd (%r15), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x2869e3
sqrtss %xmm5, %xmm5
movss 0xfc7a8(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0xfc79d(%rip), %xmm3 # 0x383188
movq 0x48(%r14), %rdx
movlps %xmm2, 0x8(%rdx)
movq 0x48(%r14), %rsi
movl %ecx, 0x10(%rsi)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rdx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rdx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%rsi)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%rsi)
movlps %xmm2, 0x1c(%rsi)
movq 0x48(%r14), %rdx
movl %ecx, 0x24(%rdx)
movss %xmm1, 0x28(%rdx)
movss %xmm4, 0x2c(%rdx)
movlps %xmm2, 0x30(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x38(%rdx)
movsd 0x1c(%rbx), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x4c(%rdx)
addq $0x50, %rdx
movq %rdx, 0x48(%r14)
movl 0x34(%r14), %ecx
movq 0x50(%r14), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%r14), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%r14), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%r14), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%r14)
addl $0x4, 0x34(%r14)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderMarkers<ImPlot::TransformerLogLog, ImPlot::GetterXsYs<unsigned int>>(ImPlot::GetterXsYs<unsigned int>, ImPlot::TransformerLogLog, ImDrawList&, int, float, bool, unsigned int, float, bool, unsigned int)
|
inline void RenderMarkers(Getter getter, Transformer transformer, ImDrawList& DrawList, ImPlotMarker marker, float size, bool rend_mk_line, ImU32 col_mk_line, float weight, bool rend_mk_fill, ImU32 col_mk_fill) {
static void (*marker_table[ImPlotMarker_COUNT])(ImDrawList&, const ImVec2&, float s, bool, ImU32, bool, ImU32, float) = {
RenderMarkerCircle,
RenderMarkerSquare,
RenderMarkerDiamond ,
RenderMarkerUp ,
RenderMarkerDown ,
RenderMarkerLeft,
RenderMarkerRight,
RenderMarkerCross,
RenderMarkerPlus,
RenderMarkerAsterisk
};
ImPlotContext& gp = *GImPlot;
for (int i = 0; i < getter.Count; ++i) {
ImVec2 c = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Contains(c))
marker_table[marker](DrawList, c, size, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, weight);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movss %xmm1, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movq %rsi, 0x38(%rsp)
movl 0xf0(%rsp), %ebp
testl %ebp, %ebp
jle 0x287d2d
leaq 0xe0(%rsp), %rax
movq 0x1e28f6(%rip), %rsi # 0x46a3f0
movq (%rsi), %rsi
movq %rsi, 0x60(%rsp)
movq (%rax), %rsi
movq %rsi, 0x58(%rsp)
movq 0x8(%rax), %rsi
movq %rsi, 0x50(%rsp)
movl 0x14(%rax), %esi
movq %rsi, 0x48(%rsp)
movslq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movslq %edi, %r15
movslq %edx, %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
movq %r15, %rbx
shlq $0x7, %rbx
movq %r15, %r12
shlq $0x4, %r12
movzbl %cl, %eax
movl %eax, 0x10(%rsp)
movzbl %r9b, %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rax
addl %r14d, %eax
cltd
idivl %ebp
leal (%rdx,%rbp), %eax
cltd
idivl %ebp
movslq %edx, %rax
imulq 0x40(%rsp), %rax
movq 0x58(%rsp), %rcx
movl (%rcx,%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movq 0x50(%rsp), %rcx
movl (%rcx,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x20(%rsp)
movq 0x1e285a(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movsd 0x20(%rsp), %xmm1
divsd 0x98(%rax,%rbx), %xmm1
movapd %xmm0, 0x70(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x80(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x90(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movapd 0x70(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x80(%rsp), %xmm0
movhpd 0x1c0(%r13,%r15,8), %xmm0 # xmm0 = xmm0[0],mem[0]
divpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd 0x90(%rsp), %xmm3
movhpd 0xa0(%rax,%rbx), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x98(%rax,%rbx), %xmm1
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulpd %xmm4, %xmm0
cvtps2pd 0x164(%r13,%r12), %xmm2
addpd %xmm3, %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
subpd %xmm3, %xmm0
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%r15,8), %xmm1 # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rax
ucomiss 0x2b8(%rax), %xmm0
jae 0x287cb1
incl %r14d
cmpl %r14d, %ebp
jne 0x287b4f
jmp 0x287d2d
movsd 0x2bc(%rax), %xmm1
movaps %xmm1, %xmm2
shufps $0xe1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[2,3]
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
ucomiss %xmm0, %xmm1
seta %cl
cmpleps %xmm0, %xmm2
pextrw $0x2, %xmm2, %edx
testb $0x1, %dl
je 0x287ca3
testb %cl, %cl
je 0x287ca3
movss 0x2c4(%rax), %xmm1
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
ucomiss %xmm0, %xmm1
jbe 0x287ca3
movq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movss 0x14(%rsp), %xmm0
movl 0x10(%rsp), %edx
movl 0x18(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x100(%rsp), %r9d
movss 0x1c(%rsp), %xmm1
movq 0x30(%rsp), %rax
movq 0x1e45ec(%rip), %r10 # 0x46c310
callq *(%r10,%rax,8)
jmp 0x287ca3
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterXsYs<unsigned int>, ImPlot::TransformerLinLog>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rbp
movl 0x10(%rcx), %edi
movl 0x14(%rcx), %eax
movslq 0x18(%rcx), %r9
addl %r8d, %eax
incl %eax
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r9, %rax
movq (%rcx), %rdx
movl (%rdx,%rax), %edx
cvtsi2sd %rdx, %xmm0
movapd %xmm0, (%rsp)
movq 0x8(%rcx), %rcx
movl (%rcx,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rsi, %r14
movq 0x1e1dd2(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
movslq (%rbp), %rcx
shlq $0x7, %rcx
divsd 0x98(%rax,%rcx), %xmm0
callq 0xe2ca0
movslq (%rbp), %rcx
divsd 0x1c0(%r13,%rcx,8), %xmm0
movq 0x28(%r13), %rax
movq %rcx, %rdx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
cvtsd2ss %xmm0, %xmm0
movsd 0xa0(%rax,%rcx), %xmm3
subsd %xmm2, %xmm3
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
shlq $0x4, %rdx
cvtps2pd 0x164(%r13,%rdx), %xmm3
movapd (%rsp), %xmm4
unpcklpd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0]
movsd 0x18(%rax), %xmm0
unpcklpd %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0]
subpd %xmm0, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movsd 0x1c(%rbx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r12), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x288842
movss 0x18(%rbx), %xmm3
movl 0x14(%rbx), %ecx
movsd (%r15), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x288753
sqrtss %xmm5, %xmm5
movss 0xfaa38(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0xfaa2d(%rip), %xmm3 # 0x383188
movq 0x48(%r14), %rdx
movlps %xmm2, 0x8(%rdx)
movq 0x48(%r14), %rsi
movl %ecx, 0x10(%rsi)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rdx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rdx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%rsi)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%rsi)
movlps %xmm2, 0x1c(%rsi)
movq 0x48(%r14), %rdx
movl %ecx, 0x24(%rdx)
movss %xmm1, 0x28(%rdx)
movss %xmm4, 0x2c(%rdx)
movlps %xmm2, 0x30(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x38(%rdx)
movsd 0x1c(%rbx), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x4c(%rdx)
addq $0x50, %rdx
movq %rdx, 0x48(%r14)
movl 0x34(%r14), %ecx
movq 0x50(%r14), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%r14), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%r14), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%r14), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%r14)
addl $0x4, 0x34(%r14)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterXsYs<long long>, ImPlot::TransformerLogLin>(ImPlot::GetterXsYs<long long> const&, ImPlot::TransformerLogLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e142a(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x288fe2
cmpb $0x1, 0x448(%r13)
jne 0x28922e
movl 0x10(%r15), %esi
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rsi
xorps %xmm0, %xmm0
cvtsi2sdq (%rdx,%rax), %xmm0
cvtsi2sdq (%rsi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movslq (%r14), %rcx
movq %rcx, %rdx
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%r13,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x30(%rsp)
movl 0x10(%r15), %ecx
cmpl $0x2, %ecx
jl 0x28932e
movl $0x1, %ebx
movslq 0x18(%r15), %rsi
movl 0x14(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq (%rdx,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movsd 0x198(%rbp), %xmm2
movhpd 0x1a0(%rbp,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rcx, %rdx
shlq $0x4, %rcx
shlq $0x7, %rdx
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x28(%rsp)
movq 0x28(%r13), %rcx
movss 0x34(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x289216
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x289216
movss 0x30(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x289216
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x289216
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
incl %ebx
movl 0x10(%r15), %ecx
cmpl %ecx, %ebx
jl 0x2890b3
jmp 0x28932e
leaq 0x30(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x10(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rsi
xorps %xmm0, %xmm0
cvtsi2sdq (%rdx,%rax), %xmm0
cvtsi2sdq (%rsi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rdx
movupd 0x18(%rdx), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rax
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rax,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rax, %rcx
shlq $0x4, %rax
shlq $0x7, %rcx
cvtps2pd 0x164(%r13,%rax), %xmm3
movhpd 0x98(%rdx,%rcx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0xe5010
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterXsYs<long long>, ImPlot::TransformerLogLog>(ImPlot::GetterXsYs<long long> const&, ImPlot::TransformerLogLog const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, 0x18(%rsp)
movss %xmm0, 0x1c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1e0ca0(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x28976c
cmpb $0x1, 0x448(%r13)
jne 0x289a8f
movl 0x10(%r15), %esi
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rsi
xorps %xmm0, %xmm0
cvtsi2sdq (%rdx,%rax), %xmm0
cvtsi2sdq (%rsi,%rax), %xmm1
movsd %xmm1, (%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x30(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rdx
movq 0x28(%r13), %rax
movq %rdx, %rcx
movapd 0x20(%rsp), %xmm2
movhpd 0x1c0(%r13,%rdx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movsd 0x198(%r13), %xmm0
movhpd 0x1a0(%r13,%rdx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x40(%rsp), %xmm5
movhpd 0xa0(%rax,%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtps2pd %xmm1, %xmm1
subpd %xmm3, %xmm5
movapd %xmm3, %xmm4
mulpd %xmm5, %xmm1
cvtps2pd 0x164(%r13,%rcx), %xmm3
addpd %xmm4, %xmm1
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x60(%rsp)
movl 0x10(%r15), %ecx
cmpl $0x2, %ecx
jl 0x289bf9
movl $0x1, %ebx
movslq 0x18(%r15), %rsi
movl 0x14(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
xorps %xmm0, %xmm0
cvtsi2sdq (%rcx,%rax), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq (%rdx,%rax), %xmm1
movsd %xmm1, (%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%rbp), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%rbp), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rdx
movq 0x28(%rbp), %rax
movq %rdx, %rcx
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x30(%rsp), %xmm2
movhpd 0x1c0(%rbp,%rdx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movsd 0x198(%rbp), %xmm0
movhpd 0x1a0(%rbp,%rdx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x40(%rsp), %xmm4
movhpd 0xa0(%rax,%rdx), %xmm4 # xmm4 = xmm4[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
cvtps2pd %xmm1, %xmm1
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x58(%rsp)
movq 0x28(%r13), %rcx
movss 0x64(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x289a77
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x289a77
movss 0x60(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x289a77
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x289a77
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movl 0x18(%rsp), %ecx
movss 0x1c(%rsp), %xmm0
callq 0xe5ce0
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
incl %ebx
movl 0x10(%r15), %ecx
cmpl %ecx, %ebx
jl 0x2898ab
jmp 0x289bf9
leaq 0x60(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x10(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rsi
xorps %xmm0, %xmm0
cvtsi2sdq (%rdx,%rax), %xmm0
cvtsi2sdq (%rsi,%rax), %xmm1
movsd %xmm1, (%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x40(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
movq 0x28(%r13), %rdx
movq %rcx, %rax
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x30(%rsp), %xmm2
movhpd 0x1c0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movsd 0x198(%r13), %xmm0
movhpd 0x1a0(%r13,%rcx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rcx
shlq $0x4, %rax
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x40(%rsp), %xmm4
movhpd 0xa0(%rdx,%rcx), %xmm4 # xmm4 = xmm4[0],mem[0]
movsd 0x98(%rdx,%rcx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
cvtps2pd %xmm1, %xmm1
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
cvtps2pd 0x164(%r13,%rax), %xmm3
movsd 0x18(%rdx), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x50(%rsp), %rsi
callq 0xeb770
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::LineStripRenderer<ImPlot::GetterXsYs<long long>, ImPlot::TransformerLogLin>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddLine(P1,P2,Weight,Col,DrawList,uv);
P1 = P2;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %r13
movl 0x10(%rcx), %esi
movl 0x14(%rcx), %eax
movslq 0x18(%rcx), %rdi
addl %r8d, %eax
incl %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%rcx), %rdx
cvtsi2sdq (%rdx,%rax), %xmm0
movq 0x8(%rcx), %rcx
cvtsi2sdq (%rcx,%rax), %xmm1
movapd %xmm1, (%rsp)
movq 0x1e0059(%rip), %rax # 0x46a3f0
movq (%rax), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd (%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movslq (%r13), %rcx
movq %rcx, %rdx
movsd 0x198(%rbp), %xmm2
movhpd 0x1a0(%rbp,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%rbp,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movsd 0x1c(%rbx), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r12), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x28a5a1
movss 0x18(%rbx), %xmm3
movl 0x14(%rbx), %ecx
movsd (%r15), %xmm2
movapd %xmm0, %xmm4
subps %xmm1, %xmm4
movaps %xmm4, %xmm6
mulps %xmm4, %xmm6
shufps $0x55, %xmm6, %xmm6 # xmm6 = xmm6[1,1,1,1]
movaps %xmm4, %xmm5
mulss %xmm4, %xmm5
addss %xmm6, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm5
jbe 0x28a4b2
sqrtss %xmm5, %xmm5
movss 0xf8cd9(%rip), %xmm6 # 0x383180
divss %xmm5, %xmm6
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
mulps %xmm6, %xmm4
mulss 0xf8cce(%rip), %xmm3 # 0x383188
movq 0x48(%r14), %rdx
movlps %xmm2, 0x8(%rdx)
movq 0x48(%r14), %rsi
movl %ecx, 0x10(%rsi)
movapd %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm4, %xmm3
movaps %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm4 # xmm4 = xmm4[1,1],xmm3[1,1]
movaps %xmm1, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rdx)
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
subss %xmm3, %xmm1
movss %xmm1, 0x4(%rdx)
movaps %xmm0, %xmm1
subss %xmm4, %xmm1
addss %xmm0, %xmm4
movss %xmm4, 0x14(%rsi)
movaps %xmm3, %xmm4
addss %xmm5, %xmm4
subss %xmm3, %xmm5
movss %xmm5, 0x18(%rsi)
movlps %xmm2, 0x1c(%rsi)
movq 0x48(%r14), %rdx
movl %ecx, 0x24(%rdx)
movss %xmm1, 0x28(%rdx)
movss %xmm4, 0x2c(%rdx)
movlps %xmm2, 0x30(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x38(%rdx)
movsd 0x1c(%rbx), %xmm1
shufps $0xe1, %xmm1, %xmm1 # xmm1 = xmm1[1,0,2,3]
movaps %xmm1, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm1
shufps $0x10, %xmm4, %xmm1 # xmm1 = xmm1[0,0],xmm4[1,0]
shufps $0x42, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[0,1]
movups %xmm1, 0x3c(%rdx)
movq 0x48(%r14), %rdx
movl %ecx, 0x4c(%rdx)
addq $0x50, %rdx
movq %rdx, 0x48(%r14)
movl 0x34(%r14), %ecx
movq 0x50(%r14), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%r14), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%r14), %ecx
movl %ecx, 0xc(%rdx)
addl $0x2, %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%r14), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%r14)
addl $0x4, 0x34(%r14)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterXsYs<unsigned long long>, ImPlot::TransformerLinLin>(ImPlot::GetterXsYs<unsigned long long> const&, ImPlot::TransformerLinLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1df609(%rip), %r11 # 0x46a3f0
movq (%r11), %r12
movq 0x28(%r12), %r10
testb $0x10, 0x5(%r10)
jne 0x28ae05
cmpb $0x1, 0x448(%r12)
jne 0x28b0be
movl 0x10(%r15), %esi
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rdx
imulq %rdi, %rdx
movq (%r15), %rdi
movq 0x8(%r15), %r8
movslq (%r14), %r9
movq %r9, %rax
movsd 0x1a0(%r12,%r9,8), %xmm4
shlq $0x4, %r9
movq (%rdi,%rdx), %xmm1
movq (%r8,%rdx), %xmm2
punpcklqdq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movdqa 0x11e8fd(%rip), %xmm1 # 0x3a9750
pand %xmm2, %xmm1
por 0x11e8e1(%rip), %xmm1 # 0x3a9740
shlq $0x7, %rax
psrlq $0x20, %xmm2
por 0x11e8f0(%rip), %xmm2 # 0x3a9760
subpd 0x11e8f8(%rip), %xmm2 # 0x3a9770
cvtps2pd 0x164(%r12,%r9), %xmm3
addpd %xmm1, %xmm2
movsd 0x98(%r10,%rax), %xmm1
movhpd 0x18(%r10), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm2
shufpd $0x1, %xmm3, %xmm3 # xmm3 = xmm3[1,0]
movhpd 0x198(%r12), %xmm4 # xmm4 = xmm4[0],mem[0]
mulpd %xmm2, %xmm4
addpd %xmm3, %xmm4
cvtpd2ps %xmm4, %xmm5
movapd %xmm5, %xmm1
shufps $0xe1, %xmm5, %xmm1 # xmm1 = xmm1[1,0],xmm5[2,3]
movlps %xmm1, 0x20(%rsp)
cmpl $0x2, %esi
jl 0x28b199
movl $0x1, %r13d
movdqa 0x11e878(%rip), %xmm6 # 0x3a9750
movdqa 0x11e860(%rip), %xmm7 # 0x3a9740
movdqa 0x11e877(%rip), %xmm8 # 0x3a9760
movapd 0x11e87e(%rip), %xmm9 # 0x3a9770
movq %r12, %rbp
movss %xmm0, 0xc(%rsp)
movq %r12, 0x18(%rsp)
movslq 0x18(%r15), %rdi
movl 0x14(%r15), %eax
addl %r13d, %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rdx
imulq %rdi, %rdx
movq (%r15), %rdi
movq 0x8(%r15), %r8
movslq (%r14), %r9
movq %r9, %rax
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%r9,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x4, %r9
movq 0x28(%rbp), %r10
shlq $0x7, %rax
movq (%r8,%rdx), %xmm2
movq (%rdi,%rdx), %xmm3
punpcklqdq %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
movdqa %xmm3, %xmm2
pand %xmm6, %xmm2
por %xmm7, %xmm2
psrlq $0x20, %xmm3
por %xmm8, %xmm3
subpd %xmm9, %xmm3
addpd %xmm2, %xmm3
cvtps2pd 0x164(%rbp,%r9), %xmm2
movsd 0x18(%r10), %xmm4
movhpd 0x98(%r10,%rax), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm3
mulpd %xmm3, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movlpd %xmm1, 0x10(%rsp)
movq 0x28(%r12), %rdx
movq %xmm1, %rax
movapd %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2 # xmm2 = xmm2[1,1],xmm1[1,1]
movaps %xmm5, %xmm3
minss %xmm2, %xmm3
movss 0x2c4(%rdx), %xmm4
ucomiss %xmm3, %xmm4
shufps $0x51, %xmm1, %xmm1 # xmm1 = xmm1[1,0,1,1]
jbe 0x28b0a5
movaps %xmm2, %xmm3
cmpless %xmm5, %xmm3
movaps %xmm3, %xmm4
andps %xmm5, %xmm4
andnps %xmm2, %xmm3
orps %xmm4, %xmm3
ucomiss 0x2bc(%rdx), %xmm3
jbe 0x28b0a5
movd %eax, %xmm2
shufps $0x55, %xmm5, %xmm5 # xmm5 = xmm5[1,1,1,1]
movaps %xmm5, %xmm3
minss %xmm2, %xmm3
movss 0x2c0(%rdx), %xmm4
ucomiss %xmm3, %xmm4
jbe 0x28b0a5
movaps %xmm2, %xmm3
cmpless %xmm5, %xmm3
movaps %xmm3, %xmm4
andnps %xmm2, %xmm4
andps %xmm5, %xmm3
orps %xmm4, %xmm3
ucomiss 0x2b8(%rdx), %xmm3
jbe 0x28b0a5
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %r12
movl %ecx, %r14d
movq %rbx, %rbp
movq %r11, %rbx
callq 0xe5ce0
movapd 0x11e71a(%rip), %xmm9 # 0x3a9770
movdqa 0x11e701(%rip), %xmm8 # 0x3a9760
movdqa 0x11e6d9(%rip), %xmm7 # 0x3a9740
movdqa 0x11e6e1(%rip), %xmm6 # 0x3a9750
movq %rbx, %r11
movq %rbp, %rbx
movl %r14d, %ecx
movq %r12, %r14
movq 0x18(%rsp), %r12
movss 0xc(%rsp), %xmm0
movq (%r11), %rbp
movq 0x10(%rsp), %rax
movl 0x10(%r15), %esi
movq %rax, %rdx
shrq $0x20, %rdx
movd %eax, %xmm2
movd %edx, %xmm1
punpckldq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movq %rax, 0x20(%rsp)
incl %r13d
movaps %xmm1, %xmm5
cmpl %esi, %r13d
jl 0x28af00
jmp 0x28b199
leaq 0x20(%rsp), %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movl 0x10(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movss %xmm0, 0x18(%rdi)
movl 0x14(%r15), %eax
movslq 0x18(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rdx
imulq %r8, %rdx
movq (%r15), %rsi
movq 0x8(%r15), %r8
movslq (%r14), %r9
movq %r9, %rax
movsd 0x198(%r12), %xmm0
movhpd 0x1a0(%r12,%r9,8), %xmm0 # xmm0 = xmm0[0],mem[0]
movq (%r8,%rdx), %xmm1
movq (%rsi,%rdx), %xmm2
punpcklqdq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movdqa 0x11e624(%rip), %xmm1 # 0x3a9750
pand %xmm2, %xmm1
por 0x11e608(%rip), %xmm1 # 0x3a9740
shlq $0x4, %r9
psrlq $0x20, %xmm2
por 0x11e617(%rip), %xmm2 # 0x3a9760
shlq $0x7, %rax
subpd 0x11e61b(%rip), %xmm2 # 0x3a9770
addpd %xmm1, %xmm2
movsd 0x18(%r10), %xmm1
movhpd 0x98(%r10,%rax), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm2
cvtps2pd 0x164(%r12,%r9), %xmm1
mulpd %xmm2, %xmm0
addpd %xmm1, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x1c(%rdi)
addq $0x2b8, %r10 # imm = 0x2B8
movq %rbx, %rsi
movq %r10, %rdx
callq 0xe5f50
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterXsYs<unsigned long long>, ImPlot::TransformerLinLog>(ImPlot::GetterXsYs<unsigned long long> const&, ImPlot::TransformerLinLog const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1deded(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x28b61f
cmpb $0x1, 0x448(%r13)
jne 0x28b8f4
movl 0x10(%r15), %esi
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movsd (%rdx,%rax), %xmm0
movsd 0xf1da1(%rip), %xmm2 # 0x37d3f0
unpcklps %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xf1da6(%rip), %xmm3 # 0x37d400
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd (%rsi,%rax), %xmm1
unpcklps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%r13,%rcx,8), %xmm0
movq 0x28(%r13), %rax
movq %rcx, %rdx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
cvtsd2ss %xmm0, %xmm0
movsd 0xa0(%rax,%rcx), %xmm3
subsd %xmm2, %xmm3
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
shlq $0x4, %rdx
movsd 0x18(%rax), %xmm0
unpcklpd %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0]
cvtps2pd 0x164(%r13,%rdx), %xmm2
subpd %xmm0, %xmm3
mulpd %xmm3, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x30(%rsp)
movl 0x10(%r15), %ecx
cmpl $0x2, %ecx
jl 0x28ba3a
movl $0x1, %ebx
movslq 0x18(%r15), %rsi
movl 0x14(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rsi, %rax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
movsd (%rcx,%rax), %xmm0
movsd 0xf1c8c(%rip), %xmm2 # 0x37d3f0
unpcklps %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xf1c91(%rip), %xmm3 # 0x37d400
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd (%rdx,%rax), %xmm1
unpcklps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq (%r12), %rbp
movq 0x28(%rbp), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
divsd 0x98(%rax,%rcx), %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
divsd 0x1c0(%rbp,%rcx,8), %xmm0
movq 0x28(%rbp), %rax
movsd 0x198(%rbp), %xmm1
movhpd 0x1a0(%rbp,%rcx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rcx, %rdx
shlq $0x7, %rcx
movsd 0x98(%rax,%rcx), %xmm2
movsd 0xa0(%rax,%rcx), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0]
shlq $0x4, %rdx
cvtps2pd 0x164(%rbp,%rdx), %xmm0
movsd 0x18(%rax), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x28(%rsp)
movq 0x28(%r13), %rcx
movss 0x34(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x28b8dc
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x28b8dc
movss 0x30(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x28b8dc
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x28b8dc
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
incl %ebx
movl 0x10(%r15), %ecx
cmpl %ecx, %ebx
jl 0x28b736
jmp 0x28ba3a
leaq 0x30(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x10(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movl 0x14(%r15), %eax
movslq 0x18(%r15), %rdi
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %rdi, %rax
movq (%r15), %rdx
movq 0x8(%r15), %rsi
movsd (%rdx,%rax), %xmm0
movsd 0xf1aa0(%rip), %xmm1 # 0x37d3f0
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xf1aa5(%rip), %xmm2 # 0x37d400
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3 # xmm3 = xmm3[1],xmm0[1]
addpd %xmm0, %xmm3
movapd %xmm3, 0x10(%rsp)
movsd (%rsi,%rax), %xmm3
unpcklps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0 # xmm0 = xmm0[1],xmm3[1]
addsd %xmm3, %xmm0
movslq (%r14), %rax
shlq $0x7, %rax
divsd 0x98(%rcx,%rax), %xmm0
callq 0xe2ca0
movslq (%r14), %rax
divsd 0x1c0(%r13,%rax,8), %xmm0
movq 0x28(%r13), %rdx
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rax,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rax, %rcx
shlq $0x7, %rax
movsd 0x98(%rdx,%rax), %xmm2
movsd 0xa0(%rdx,%rax), %xmm3
cvtsd2ss %xmm0, %xmm0
subsd %xmm2, %xmm3
cvtss2sd %xmm0, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd 0x10(%rsp), %xmm4
unpcklpd %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%r13,%rcx), %xmm0
movsd 0x18(%rdx), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
mulpd %xmm4, %xmm1
addpd %xmm0, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0xe5ab0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::LineStripRenderer<ImPlot::GetterXsYs<unsigned long long>, ImPlot::TransformerLinLog>>(ImPlot::LineStripRenderer<ImPlot::GetterXsYs<unsigned long long>, ImPlot::TransformerLinLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x28cb2b
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x2, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x28ca8d
testl %ebp, %ebp
je 0x28ca79
leal (,%rbp,2), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x3fffffff, %eax # imm = 0x3FFFFFFF
cmpl %eax, %esi
movl $0x3fffffff, %edx # imm = 0x3FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x28ca99
movl %ebp, %eax
subl %r13d, %eax
jae 0x28cafe
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (%rdx,%rdx), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe3130
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x28cac4
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x28ca36
jmp 0x28cb10
subl %r13d, %esi
cmpl $-0x5, %edi
jbe 0x28cb0a
movl %eax, %ebp
jmp 0x28caf4
movl %esi, 0x4(%rsp)
jmp 0x28caba
testl %ebp, %ebp
je 0x28cb2b
leal (,%rbp,2), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::LineStripRenderer<ImPlot::GetterXsYs<float>, ImPlot::TransformerLogLog>>(ImPlot::LineStripRenderer<ImPlot::GetterXsYs<float>, ImPlot::TransformerLogLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x28f091
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x2, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x28eff3
testl %ebp, %ebp
je 0x28efdf
leal (,%rbp,2), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x3fffffff, %eax # imm = 0x3FFFFFFF
cmpl %eax, %esi
movl $0x3fffffff, %edx # imm = 0x3FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x28efff
movl %ebp, %eax
subl %r13d, %eax
jae 0x28f064
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (%rdx,%rdx), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe6cd0
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x28f02a
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x28ef9c
jmp 0x28f076
subl %r13d, %esi
cmpl $-0x5, %edi
jbe 0x28f070
movl %eax, %ebp
jmp 0x28f05a
movl %esi, 0x4(%rsp)
jmp 0x28f020
testl %ebp, %ebp
je 0x28f091
leal (,%rbp,2), %eax
leal (%rax,%rax,2), %esi
shll $0x2, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderLineStrip<ImPlot::GetterFuncPtr, ImPlot::TransformerLogLin>(ImPlot::GetterFuncPtr const&, ImPlot::TransformerLogLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderLineStrip(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2))))
DrawList.AddLine(p1, p2, col, line_weight);
p1 = p2;
}
}
else {
RenderPrimitives(LineStripRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d8cdc(%rip), %rbx # 0x46a3f0
movq (%rbx), %r13
movq 0x28(%r13), %rax
testb $0x10, 0x5(%rax)
jne 0x29172f
cmpb $0x1, 0x448(%r13)
jne 0x291930
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq *(%r15)
movaps %xmm1, 0x10(%rsp)
movq (%rbx), %r12
movq 0x28(%r12), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r12), %xmm0
movq 0x28(%r12), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movq %rcx, %rdx
movsd 0x198(%r12), %xmm2
movhpd 0x1a0(%r12,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
cvtps2pd 0x164(%r12,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x30(%rsp)
cmpl $0x2, 0x10(%r15)
jl 0x291a0e
movl $0x1, %r12d
movq 0x8(%r15), %rdi
movl %r12d, %esi
callq *(%r15)
movapd %xmm1, 0x10(%rsp)
movq (%rbx), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movsd 0x198(%rbp), %xmm2
movhpd 0x1a0(%rbp,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rcx, %rdx
shlq $0x4, %rcx
shlq $0x7, %rdx
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x28(%rsp)
movq 0x28(%r13), %rcx
movss 0x34(%rsp), %xmm1
movq %xmm0, %rax
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm1, %xmm2
minss %xmm0, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x291919
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x291919
movss 0x30(%rsp), %xmm0
movd %eax, %xmm1
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c0(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x291919
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andnps %xmm1, %xmm3
andps %xmm0, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2b8(%rcx), %xmm2
jbe 0x291919
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl 0x8(%rsp), %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
incl %r12d
cmpl 0x10(%r15), %r12d
jl 0x2917e0
jmp 0x291a0e
leaq 0x30(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x10(%r15), %eax
decl %eax
movl %eax, 0x10(%r12)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x18(%r12)
movq 0x8(%r15), %rdi
xorl %esi, %esi
callq *(%r15)
movaps %xmm1, 0x10(%rsp)
movq (%rbx), %rbx
movq 0x28(%rbx), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbx), %xmm0
movq 0x28(%rbx), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movq %rcx, %rdx
movsd 0x198(%rbx), %xmm2
movhpd 0x1a0(%rbx,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
cvtps2pd 0x164(%rbx,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x1c(%r12)
movl $0x2b8, %edx # imm = 0x2B8
addq 0x28(%r13), %rdx
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0xe0ec0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderStairs<ImPlot::GetterYs<signed char>, ImPlot::TransformerLinLin>(ImPlot::GetterYs<signed char> const&, ImPlot::TransformerLinLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderStairs(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2)))) {
ImVec2 p12(p2.x, p1.y);
DrawList.AddLine(p1, p12, col, line_weight);
DrawList.AddLine(p12, p2, col, line_weight);
}
p1 = p2;
}
}
else {
RenderPrimitives(StairsRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x1d70bc(%rip), %rax # 0x46a3f0
movq (%rax), %r12
movq 0x28(%r12), %rcx
testb $0x10, 0x5(%rcx)
jne 0x293351
cmpb $0x1, 0x448(%r12)
jne 0x29359f
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rdi
movl 0x8(%r15), %esi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
movsbl (%rdi,%rax), %eax
cvtsi2sd %eax, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movslq (%rbx), %rax
movq %rax, %rdx
movsd 0x1a0(%r12,%rax,8), %xmm0
shlq $0x4, %rax
cvtps2pd 0x164(%r12,%rax), %xmm2
shlq $0x7, %rdx
movsd 0x98(%rcx,%rdx), %xmm3
movhpd 0x18(%rcx), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm1
shufpd $0x1, %xmm2, %xmm2 # xmm2 = xmm2[1,0]
movhpd 0x198(%r12), %xmm0 # xmm0 = xmm0[0],mem[0]
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
cvtpd2ps %xmm0, %xmm0
movapd %xmm0, %xmm1
shufps $0xe1, %xmm0, %xmm1 # xmm1 = xmm1[1,0],xmm0[2,3]
movlps %xmm1, 0x20(%rsp)
cmpl $0x2, %esi
jl 0x293667
movl $0x1, %r13d
movq %r12, %rcx
movq 0x10(%rsp), %rbp
movl 0x4(%rsp), %r14d
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
mulsd 0x10(%r15), %xmm1
addsd 0x18(%r15), %xmm1
movq (%r15), %rdi
movslq 0x24(%r15), %r8
movl 0x20(%r15), %eax
addl %r13d, %eax
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
movsbl (%rdi,%rax), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
unpcklpd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
movslq (%rbx), %rax
movq %rax, %rdx
movsd 0x198(%rcx), %xmm2
movhpd 0x1a0(%rcx,%rax,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rax
movq 0x28(%rcx), %rdi
shlq $0x7, %rdx
cvtps2pd 0x164(%rcx,%rax), %xmm3
movsd 0x18(%rdi), %xmm4
movhpd 0x98(%rdi,%rdx), %xmm4 # xmm4 = xmm4[0],mem[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm1
movlpd %xmm1, 0x18(%rsp)
movq 0x28(%r12), %rdx
movq %xmm1, %rax
movapd %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm0, %xmm2
minss %xmm3, %xmm2
movss 0x2c4(%rdx), %xmm4
ucomiss %xmm2, %xmm4
shufps $0x51, %xmm1, %xmm1 # xmm1 = xmm1[1,0,1,1]
jbe 0x293586
movaps %xmm3, %xmm4
cmpless %xmm0, %xmm4
movaps %xmm4, %xmm5
andps %xmm0, %xmm5
andnps %xmm3, %xmm4
orps %xmm5, %xmm4
ucomiss 0x2bc(%rdx), %xmm4
jbe 0x293586
movaps %xmm0, %xmm2
movd %eax, %xmm3
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
movaps %xmm0, %xmm4
minss %xmm3, %xmm4
movss 0x2c0(%rdx), %xmm5
ucomiss %xmm4, %xmm5
jbe 0x293586
movaps %xmm3, %xmm4
cmpless %xmm0, %xmm4
movaps %xmm4, %xmm5
andnps %xmm3, %xmm5
andps %xmm0, %xmm4
orps %xmm5, %xmm4
ucomiss 0x2b8(%rdx), %xmm4
jbe 0x293586
movl %eax, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
movq %rbp, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movl %r14d, %ecx
movss (%rsp), %xmm0
callq 0xe5ce0
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movl %r14d, %ecx
movss (%rsp), %xmm0
callq 0xe5ce0
movq 0x1d6e89(%rip), %rax # 0x46a3f0
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movl 0x8(%r15), %esi
movq %rax, %rdx
shrq $0x20, %rdx
movd %eax, %xmm0
movd %edx, %xmm1
punpckldq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movq %rax, 0x20(%rsp)
incl %r13d
movaps %xmm1, %xmm0
cmpl %esi, %r13d
jl 0x293403
jmp 0x293667
leaq 0x20(%rsp), %rdi
movq %r15, (%rdi)
movq %rbx, 0x8(%rdi)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rdi)
movss (%rsp), %xmm0
mulss 0xefbbf(%rip), %xmm0 # 0x383188
movss %xmm0, 0x18(%rdi)
xorps %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %r8
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r9
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r9, %rax
movsbl (%r8,%rax), %eax
cvtsi2sd %eax, %xmm1
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movslq (%rbx), %rax
movsd 0x198(%r12), %xmm1
movhpd 0x1a0(%r12,%rax,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movq %rax, %rdx
shlq $0x4, %rax
shlq $0x7, %rdx
movsd 0x18(%rcx), %xmm2
movhpd 0x98(%rcx,%rdx), %xmm2 # xmm2 = xmm2[0],mem[0]
subpd %xmm2, %xmm0
cvtps2pd 0x164(%r12,%rax), %xmm2
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movlpd %xmm0, 0x1c(%rdi)
addq $0x2b8, %rcx # imm = 0x2B8
movq 0x10(%rsp), %rsi
movq %rcx, %rdx
callq 0xe9c70
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned char>, ImPlot::TransformerLogLin>>(ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned char>, ImPlot::TransformerLogLin> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x296b4e
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x3, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x296aac
testl %ebp, %ebp
je 0x296a98
leal (,%rbp,4), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x1fffffff, %eax # imm = 0x1FFFFFFF
cmpl %eax, %esi
movl $0x1fffffff, %edx # imm = 0x1FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x296ab8
movl %ebp, %eax
subl %r13d, %eax
jae 0x296b21
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (,%rdx,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe8e30
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x296ae7
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x296a55
jmp 0x296b33
subl %r13d, %esi
cmpl $-0x9, %edi
jbe 0x296b2d
movl %eax, %ebp
jmp 0x296b17
movl %esi, 0x4(%rsp)
jmp 0x296add
testl %ebp, %ebp
je 0x296b4e
leal (,%rbp,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::StairsRenderer<ImPlot::GetterYs<short>, ImPlot::TransformerLinLin>>(ImPlot::StairsRenderer<ImPlot::GetterYs<short>, ImPlot::TransformerLinLin> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x298988
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x3, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x2988e6
testl %ebp, %ebp
je 0x2988d2
leal (,%rbp,4), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x1fffffff, %eax # imm = 0x1FFFFFFF
cmpl %eax, %esi
movl $0x1fffffff, %edx # imm = 0x1FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x2988f2
movl %ebp, %eax
subl %r13d, %eax
jae 0x29895b
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (,%rdx,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe56d0
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x298921
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x29888f
jmp 0x29896d
subl %r13d, %esi
cmpl $-0x9, %edi
jbe 0x298967
movl %eax, %ebp
jmp 0x298951
movl %esi, 0x4(%rsp)
jmp 0x298917
testl %ebp, %ebp
je 0x298988
leal (,%rbp,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderStairs<ImPlot::GetterYs<unsigned short>, ImPlot::TransformerLogLin>(ImPlot::GetterYs<unsigned short> const&, ImPlot::TransformerLogLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderStairs(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2)))) {
ImVec2 p12(p2.x, p1.y);
DrawList.AddLine(p1, p12, col, line_weight);
DrawList.AddLine(p12, p2, col, line_weight);
}
p1 = p2;
}
}
else {
RenderPrimitives(StairsRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1d0722(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x299cea
cmpb $0x1, 0x448(%r13)
jne 0x299f88
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
movzwl (%rsi,%rax), %eax
cvtsi2sd %eax, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movslq (%r14), %rcx
movq %rcx, %rdx
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%r13,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x40(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x29a093
movl $0x1, %ebx
movq %r14, 0x38(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
movzwl (%rsi,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movapd %xmm1, 0x10(%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movsd 0x198(%rbp), %xmm2
movhpd 0x1a0(%rbp,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rcx, %rdx
shlq $0x4, %rcx
shlq $0x7, %rdx
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm1
movlpd %xmm1, 0x30(%rsp)
movq 0x28(%r13), %rcx
movss 0x44(%rsp), %xmm0
movq %xmm1, %rax
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x299f70
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andps %xmm0, %xmm3
andnps %xmm1, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x299f70
movss 0x40(%rsp), %xmm1
movd %eax, %xmm2
movaps %xmm1, %xmm3
minss %xmm2, %xmm3
movss 0x2c0(%rcx), %xmm4
ucomiss %xmm3, %xmm4
jbe 0x299f70
movaps %xmm2, %xmm3
cmpless %xmm1, %xmm3
movaps %xmm3, %xmm4
andnps %xmm2, %xmm4
andps %xmm1, %xmm3
orps %xmm4, %xmm3
ucomiss 0x2b8(%rcx), %xmm3
jbe 0x299f70
movl %eax, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq 0x28(%rsp), %rbp
movq %rbp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %r14
movl 0x4(%rsp), %r12d
movl %r12d, %ecx
movss (%rsp), %xmm0
callq 0xe5ce0
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl %r12d, %ecx
movq %r14, %r12
movq 0x38(%rsp), %r14
movss (%rsp), %xmm0
callq 0xe5ce0
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x299dc5
jmp 0x29a093
leaq 0x40(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x4(%rsp), %eax
movl %eax, 0x14(%r12)
movss (%rsp), %xmm0
mulss 0xe91d0(%rip), %xmm0 # 0x383188
movss %xmm0, 0x18(%r12)
xorps %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
movzwl (%rdi,%rax), %eax
cvtsi2sd %eax, %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rdx
movupd 0x18(%rdx), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rax
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rax,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rax, %rcx
shlq $0x4, %rax
shlq $0x7, %rcx
cvtps2pd 0x164(%r13,%rax), %xmm3
movhpd 0x98(%rdx,%rcx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0xeb2a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned short>, ImPlot::TransformerLogLin>>(ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned short>, ImPlot::TransformerLogLin> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x29af6e
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x3, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x29aecc
testl %ebp, %ebp
je 0x29aeb8
leal (,%rbp,4), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x1fffffff, %eax # imm = 0x1FFFFFFF
cmpl %eax, %esi
movl $0x1fffffff, %edx # imm = 0x1FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x29aed8
movl %ebp, %eax
subl %r13d, %eax
jae 0x29af41
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (,%rdx,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe6db0
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x29af07
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x29ae75
jmp 0x29af53
subl %r13d, %esi
cmpl $-0x9, %edi
jbe 0x29af4d
movl %eax, %ebp
jmp 0x29af37
movl %esi, 0x4(%rsp)
jmp 0x29aefd
testl %ebp, %ebp
je 0x29af6e
leal (,%rbp,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned short>, ImPlot::TransformerLinLog>>(ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned short>, ImPlot::TransformerLinLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x29b38e
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x3, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x29b2ec
testl %ebp, %ebp
je 0x29b2d8
leal (,%rbp,4), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x1fffffff, %eax # imm = 0x1FFFFFFF
cmpl %eax, %esi
movl $0x1fffffff, %edx # imm = 0x1FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x29b2f8
movl %ebp, %eax
subl %r13d, %eax
jae 0x29b361
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (,%rdx,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe08a0
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x29b327
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x29b295
jmp 0x29b373
subl %r13d, %esi
cmpl $-0x9, %edi
jbe 0x29b36d
movl %eax, %ebp
jmp 0x29b357
movl %esi, 0x4(%rsp)
jmp 0x29b31d
testl %ebp, %ebp
je 0x29b38e
leal (,%rbp,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderPrimitives<ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned short>, ImPlot::TransformerLogLog>>(ImPlot::StairsRenderer<ImPlot::GetterYs<unsigned short>, ImPlot::TransformerLogLog> const&, ImDrawList&, ImRect const&)
|
inline void RenderPrimitives(const Renderer& renderer, ImDrawList& DrawList, const ImRect& cull_rect) {
unsigned int prims = renderer.Prims;
unsigned int prims_culled = 0;
unsigned int idx = 0;
const ImVec2 uv = DrawList._Data->TexUvWhitePixel;
while (prims) {
// find how many can be reserved up to end of current draw command's limit
unsigned int cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - DrawList._VtxCurrentIdx) / Renderer::VtxConsumed);
// make sure at least this many elements can be rendered to avoid situations where at the end of buffer this slow path is not taken all the time
if (cnt >= ImMin(64u, prims)) {
if (prims_culled >= cnt)
prims_culled -= cnt; // reuse previous reservation
else {
DrawList.PrimReserve((cnt - prims_culled) * Renderer::IdxConsumed, (cnt - prims_culled) * Renderer::VtxConsumed); // add more elements to previous reservation
prims_culled = 0;
}
}
else
{
if (prims_culled > 0) {
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
prims_culled = 0;
}
cnt = ImMin(prims, (MaxIdx<ImDrawIdx>::Value - 0/*DrawList._VtxCurrentIdx*/) / Renderer::VtxConsumed);
DrawList.PrimReserve(cnt * Renderer::IdxConsumed, cnt * Renderer::VtxConsumed); // reserve new draw command
}
prims -= cnt;
for (unsigned int ie = idx + cnt; idx != ie; ++idx) {
if (!renderer(DrawList, cull_rect, uv, idx))
prims_culled++;
}
}
if (prims_culled > 0)
DrawList.PrimUnreserve(prims_culled * Renderer::IdxConsumed, prims_culled * Renderer::VtxConsumed);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl 0x10(%rdi), %esi
movq 0x38(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testl %esi, %esi
je 0x29b7e7
movq %rdx, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %rcx
xorl %ebp, %ebp
movl 0x34(%rbx), %edi
movl %edi, %eax
notl %eax
shrl $0x3, %eax
cmpl %eax, %esi
movl %eax, %r13d
cmovbl %esi, %r13d
cmpl $0x40, %esi
movl $0x40, %edx
cmovbl %esi, %edx
cmpl %edx, %eax
jae 0x29b745
testl %ebp, %ebp
je 0x29b731
leal (,%rbp,4), %eax
movl %esi, %r13d
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
movl %r13d, %esi
movl $0x1fffffff, %eax # imm = 0x1FFFFFFF
cmpl %eax, %esi
movl $0x1fffffff, %edx # imm = 0x1FFFFFFF
cmovbl %esi, %edx
movl %edx, %r13d
jmp 0x29b751
movl %ebp, %eax
subl %r13d, %eax
jae 0x29b7ba
movl %r13d, %edx
subl %ebp, %edx
movl %esi, %ebp
leal (,%rdx,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %edx
movq %rbx, %rdi
callq 0xe3170
subl %r13d, %ebp
movl %ebp, 0x4(%rsp)
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
leal (%r12,%r13), %edx
movl %edx, 0x14(%rsp)
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %r8d
callq 0xe4f80
leaq 0x8(%rsp), %rcx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
incl %r12d
decl %r13d
jne 0x29b780
movl 0x14(%rsp), %eax
movl %eax, %r12d
movl 0x4(%rsp), %esi
testl %esi, %esi
jne 0x29b6ee
jmp 0x29b7cc
subl %r13d, %esi
cmpl $-0x9, %edi
jbe 0x29b7c6
movl %eax, %ebp
jmp 0x29b7b0
movl %esi, 0x4(%rsp)
jmp 0x29b776
testl %ebp, %ebp
je 0x29b7e7
leal (,%rbp,4), %eax
leal (%rax,%rax,2), %esi
shll $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0xe0140
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderStairs<ImPlot::GetterYs<int>, ImPlot::TransformerLogLin>(ImPlot::GetterYs<int> const&, ImPlot::TransformerLogLin const&, ImDrawList&, float, unsigned int)
|
inline void RenderStairs(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2)))) {
ImVec2 p12(p2.x, p1.y);
DrawList.AddLine(p1, p12, col, line_weight);
DrawList.AddLine(p12, p2, col, line_weight);
}
p1 = p2;
}
}
else {
RenderPrimitives(StairsRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1ce51b(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x29bef1
cmpb $0x1, 0x448(%r13)
jne 0x29c189
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdl (%rsi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movslq (%r14), %rcx
movq %rcx, %rdx
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
shlq $0x4, %rcx
cvtps2pd 0x164(%r13,%rcx), %xmm3
shlq $0x7, %rdx
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x40(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x29c291
movl $0x1, %ebx
movq %r14, 0x38(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
xorps %xmm1, %xmm1
cvtsi2sdl (%rsi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
divsd 0x1b8(%rbp), %xmm0
movq 0x28(%rbp), %rax
movupd 0x18(%rax), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rcx
movsd 0x198(%rbp), %xmm2
movhpd 0x1a0(%rbp,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rcx, %rdx
shlq $0x4, %rcx
shlq $0x7, %rdx
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movhpd 0x98(%rax,%rdx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm1
movlpd %xmm1, 0x30(%rsp)
movq 0x28(%r13), %rcx
movss 0x44(%rsp), %xmm0
movq %xmm1, %rax
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x29c171
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andps %xmm0, %xmm3
andnps %xmm1, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x29c171
movss 0x40(%rsp), %xmm1
movd %eax, %xmm2
movaps %xmm1, %xmm3
minss %xmm2, %xmm3
movss 0x2c0(%rcx), %xmm4
ucomiss %xmm3, %xmm4
jbe 0x29c171
movaps %xmm2, %xmm3
cmpless %xmm1, %xmm3
movaps %xmm3, %xmm4
andnps %xmm2, %xmm4
andps %xmm1, %xmm3
orps %xmm4, %xmm3
ucomiss 0x2b8(%rcx), %xmm3
jbe 0x29c171
movl %eax, 0x8(%rsp)
movss %xmm0, 0xc(%rsp)
movq 0x28(%rsp), %rbp
movq %rbp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %r14
movl 0x4(%rsp), %r12d
movl %r12d, %ecx
movss (%rsp), %xmm0
callq 0xe5ce0
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movl %r12d, %ecx
movq %r14, %r12
movq 0x38(%rsp), %r14
movss (%rsp), %xmm0
callq 0xe5ce0
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x29bfc9
jmp 0x29c291
leaq 0x40(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x4(%rsp), %eax
movl %eax, 0x14(%r12)
movss (%rsp), %xmm0
mulss 0xe6fcf(%rip), %xmm0 # 0x383188
movss %xmm0, 0x18(%r12)
xorps %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdl (%rdi,%rax), %xmm1
movapd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
divsd 0x1b8(%r13), %xmm0
movq 0x28(%r13), %rdx
movupd 0x18(%rdx), %xmm1
cvtsd2ss %xmm0, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movslq (%r14), %rax
movsd 0x198(%r13), %xmm2
movhpd 0x1a0(%r13,%rax,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movq %rax, %rcx
shlq $0x4, %rax
shlq $0x7, %rcx
cvtps2pd 0x164(%r13,%rax), %xmm3
movhpd 0x98(%rdx,%rcx), %xmm1 # xmm1 = xmm1[0],mem[0]
unpcklpd 0x10(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
subpd %xmm1, %xmm0
mulpd %xmm0, %xmm2
addpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0xe9350
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::StairsRenderer<ImPlot::GetterYs<int>, ImPlot::TransformerLinLin>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddRectFilled(ImVec2(P1.x, P1.y + HalfWeight), ImVec2(P2.x, P1.y - HalfWeight), Col, DrawList, uv);
AddRectFilled(ImVec2(P2.x - HalfWeight, P2.y), ImVec2(P2.x + HalfWeight, P1.y), Col, DrawList, uv);
// AddLine(P1, P12, Weight, Col, DrawList, uv);
// AddLine(P12, P2, Weight, Col, DrawList, uv);
P1 = P2;
return true;
}
|
pushq %rbx
movq %rdx, %r9
movq (%rdi), %rdx
movq 0x8(%rdi), %r10
leal 0x1(%r8), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x10(%rdx), %xmm0
addsd 0x18(%rdx), %xmm0
movq (%rdx), %r8
movl 0x8(%rdx), %r11d
addl 0x20(%rdx), %eax
movslq 0x24(%rdx), %rbx
cltd
idivl %r11d
leal (%rdx,%r11), %eax
cltd
idivl %r11d
movslq %edx, %rax
imulq %rbx, %rax
cvtsi2sdl (%r8,%rax), %xmm1
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movq 0x1cd60d(%rip), %rax # 0x46a3f0
movq (%rax), %rax
movslq (%r10), %rdx
movq %rdx, %r8
movsd 0x198(%rax), %xmm1
movhpd 0x1a0(%rax,%rdx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x4, %rdx
movq 0x28(%rax), %r10
shlq $0x7, %r8
cvtps2pd 0x164(%rax,%rdx), %xmm2
movsd 0x18(%r10), %xmm3
movhpd 0x98(%r10,%r8), %xmm3 # xmm3 = xmm3[0],mem[0]
subpd %xmm3, %xmm0
mulpd %xmm0, %xmm1
addpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movsd 0x1c(%rdi), %xmm1
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r9), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x29d01a
movss 0x18(%rdi), %xmm2
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm3, %xmm4
addss %xmm2, %xmm4
subss %xmm2, %xmm3
movl 0x14(%rdi), %r8d
movsd (%rcx), %xmm2
movq 0x48(%rsi), %rdx
movss %xmm1, (%rdx)
movss %xmm4, 0x4(%rdx)
movq 0x48(%rsi), %rdx
movsd %xmm2, 0x8(%rdx)
movq 0x48(%rsi), %rdx
movl %r8d, 0x10(%rdx)
movss %xmm0, 0x14(%rdx)
movss %xmm3, 0x18(%rdx)
movq 0x48(%rsi), %rdx
movsd %xmm2, 0x1c(%rdx)
movq 0x48(%rsi), %rdx
movl %r8d, 0x24(%rdx)
movss %xmm1, 0x28(%rdx)
movss %xmm3, 0x2c(%rdx)
movsd %xmm2, 0x30(%rdx)
movq 0x48(%rsi), %rdx
movl %r8d, 0x38(%rdx)
movss %xmm0, 0x3c(%rdx)
movss %xmm4, 0x40(%rdx)
movsd %xmm2, 0x44(%rdx)
movq 0x48(%rsi), %rdx
movl %r8d, 0x4c(%rdx)
leaq 0x50(%rdx), %r8
movq %r8, 0x48(%rsi)
movl 0x34(%rsi), %r8d
movq 0x50(%rsi), %r9
movl %r8d, (%r9)
incl %r8d
movl %r8d, 0x4(%r9)
movl 0x34(%rsi), %r8d
addl $0x2, %r8d
movl %r8d, 0x8(%r9)
movl 0x34(%rsi), %r8d
movl %r8d, 0xc(%r9)
incl %r8d
movl %r8d, 0x10(%r9)
movl 0x34(%rsi), %r8d
addl $0x3, %r8d
movl %r8d, 0x14(%r9)
addq $0x18, %r9
movq %r9, 0x50(%rsi)
addl $0x4, 0x34(%rsi)
movss 0x18(%rdi), %xmm1
movapd %xmm0, %xmm2
subss %xmm1, %xmm2
addss %xmm0, %xmm1
movss 0x20(%rdi), %xmm3
movl 0x14(%rdi), %r8d
movsd (%rcx), %xmm4
movss %xmm2, 0x50(%rdx)
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
movss %xmm5, 0x54(%rdx)
movq 0x48(%rsi), %rcx
movsd %xmm4, 0x8(%rcx)
movq 0x48(%rsi), %rcx
movl %r8d, 0x10(%rcx)
movss %xmm1, 0x14(%rcx)
movss %xmm3, 0x18(%rcx)
movq 0x48(%rsi), %rcx
movsd %xmm4, 0x1c(%rcx)
movq 0x48(%rsi), %rcx
movl %r8d, 0x24(%rcx)
movss %xmm2, 0x28(%rcx)
movss %xmm3, 0x2c(%rcx)
movsd %xmm4, 0x30(%rcx)
movq 0x48(%rsi), %rcx
movl %r8d, 0x38(%rcx)
movss %xmm1, 0x3c(%rcx)
movss %xmm5, 0x40(%rcx)
movsd %xmm4, 0x44(%rcx)
movq 0x48(%rsi), %rcx
movl %r8d, 0x4c(%rcx)
addq $0x50, %rcx
movq %rcx, 0x48(%rsi)
movl 0x34(%rsi), %ecx
movq 0x50(%rsi), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%rsi), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%rsi), %ecx
movl %ecx, 0xc(%rdx)
incl %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%rsi), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%rsi)
addl $0x4, 0x34(%rsi)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rdi)
popq %rbx
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
ImPlot::StairsRenderer<ImPlot::GetterYs<int>, ImPlot::TransformerLogLog>::operator()(ImDrawList&, ImRect const&, ImVec2 const&, int) const
|
inline bool operator()(ImDrawList& DrawList, const ImRect& cull_rect, const ImVec2& uv, int prim) const {
ImVec2 P2 = Transformer(Getter(prim + 1));
if (!cull_rect.Overlaps(ImRect(ImMin(P1, P2), ImMax(P1, P2)))) {
P1 = P2;
return false;
}
AddRectFilled(ImVec2(P1.x, P1.y + HalfWeight), ImVec2(P2.x, P1.y - HalfWeight), Col, DrawList, uv);
AddRectFilled(ImVec2(P2.x - HalfWeight, P2.y), ImVec2(P2.x + HalfWeight, P1.y), Col, DrawList, uv);
// AddLine(P1, P12, Weight, Col, DrawList, uv);
// AddLine(P12, P2, Weight, Col, DrawList, uv);
P1 = P2;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
leal 0x1(%r8), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x10(%rcx), %xmm0
addsd 0x18(%rcx), %xmm0
movq 0x8(%rdi), %rbp
movq (%rcx), %rsi
movl 0x8(%rcx), %edi
movslq 0x24(%rcx), %r8
addl 0x20(%rcx), %eax
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
cvtsi2sdl (%rsi,%rax), %xmm1
movsd %xmm1, (%rsp)
movq 0x1cc9b7(%rip), %rax # 0x46a3f0
movq (%rax), %r13
movq 0x28(%r13), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%rbp), %rcx
shlq $0x7, %rcx
movsd (%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x20(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%rbp), %rdx
movq 0x28(%r13), %rax
movq %rdx, %rcx
movapd 0x10(%rsp), %xmm3
movhpd 0x1c0(%r13,%rdx,8), %xmm3 # xmm3 = xmm3[0],mem[0]
movsd 0x198(%r13), %xmm1
movhpd 0x1a0(%r13,%rdx,8), %xmm1 # xmm1 = xmm1[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
movapd 0x20(%rsp), %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
divpd %xmm3, %xmm2
cvtpd2ps %xmm2, %xmm0
movapd 0x30(%rsp), %xmm5
movhpd 0xa0(%rax,%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd (%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtps2pd %xmm0, %xmm0
subpd %xmm3, %xmm5
movapd %xmm3, %xmm4
mulpd %xmm5, %xmm0
cvtps2pd 0x164(%r13,%rcx), %xmm3
addpd %xmm4, %xmm0
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm0
mulpd %xmm0, %xmm1
addpd %xmm3, %xmm1
cvtpd2ps %xmm1, %xmm0
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
movsd 0x1c(%rbx), %xmm1
movaps %xmm1, %xmm3
movlhps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0]
movapd %xmm2, %xmm4
cmpleps %xmm3, %xmm4
movaps %xmm3, %xmm5
cmpltps %xmm2, %xmm5
movsd %xmm4, %xmm5 # xmm5 = xmm4[0],xmm5[1]
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movups (%r12), %xmm2
movaps %xmm2, %xmm3
cmpltps %xmm5, %xmm3
cmpltps %xmm2, %xmm5
movsd %xmm3, %xmm5 # xmm5 = xmm3[0],xmm5[1]
movmskps %xmm5, %eax
cmpl $0xf, %eax
jne 0x29dd10
movss 0x18(%rbx), %xmm2
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm3, %xmm4
addss %xmm2, %xmm4
subss %xmm2, %xmm3
movl 0x14(%rbx), %edx
movsd (%r15), %xmm2
movq 0x48(%r14), %rcx
movss %xmm1, (%rcx)
movss %xmm4, 0x4(%rcx)
movq 0x48(%r14), %rcx
movsd %xmm2, 0x8(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x10(%rcx)
movss %xmm0, 0x14(%rcx)
movss %xmm3, 0x18(%rcx)
movq 0x48(%r14), %rcx
movsd %xmm2, 0x1c(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x24(%rcx)
movss %xmm1, 0x28(%rcx)
movss %xmm3, 0x2c(%rcx)
movsd %xmm2, 0x30(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x38(%rcx)
movss %xmm0, 0x3c(%rcx)
movss %xmm4, 0x40(%rcx)
movsd %xmm2, 0x44(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x4c(%rcx)
leaq 0x50(%rcx), %rdx
movq %rdx, 0x48(%r14)
movl 0x34(%r14), %edx
movq 0x50(%r14), %rsi
movl %edx, (%rsi)
incl %edx
movl %edx, 0x4(%rsi)
movl 0x34(%r14), %edx
addl $0x2, %edx
movl %edx, 0x8(%rsi)
movl 0x34(%r14), %edx
movl %edx, 0xc(%rsi)
incl %edx
movl %edx, 0x10(%rsi)
movl 0x34(%r14), %edx
addl $0x3, %edx
movl %edx, 0x14(%rsi)
addq $0x18, %rsi
movq %rsi, 0x50(%r14)
addl $0x4, 0x34(%r14)
movss 0x18(%rbx), %xmm1
movapd %xmm0, %xmm2
subss %xmm1, %xmm2
addss %xmm0, %xmm1
movss 0x20(%rbx), %xmm3
movl 0x14(%rbx), %edx
movsd (%r15), %xmm4
movss %xmm2, 0x50(%rcx)
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
movss %xmm5, 0x54(%rcx)
movq 0x48(%r14), %rcx
movsd %xmm4, 0x8(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x10(%rcx)
movss %xmm1, 0x14(%rcx)
movss %xmm3, 0x18(%rcx)
movq 0x48(%r14), %rcx
movsd %xmm4, 0x1c(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x24(%rcx)
movss %xmm2, 0x28(%rcx)
movss %xmm3, 0x2c(%rcx)
movsd %xmm4, 0x30(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x38(%rcx)
movss %xmm1, 0x3c(%rcx)
movss %xmm5, 0x40(%rcx)
movsd %xmm4, 0x44(%rcx)
movq 0x48(%r14), %rcx
movl %edx, 0x4c(%rcx)
addq $0x50, %rcx
movq %rcx, 0x48(%r14)
movl 0x34(%r14), %ecx
movq 0x50(%r14), %rdx
movl %ecx, (%rdx)
incl %ecx
movl %ecx, 0x4(%rdx)
movl 0x34(%r14), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rdx)
movl 0x34(%r14), %ecx
movl %ecx, 0xc(%rdx)
incl %ecx
movl %ecx, 0x10(%rdx)
movl 0x34(%r14), %ecx
addl $0x3, %ecx
movl %ecx, 0x14(%rdx)
addq $0x18, %rdx
movq %rdx, 0x50(%r14)
addl $0x4, 0x34(%r14)
cmpb $0xf, %al
sete %al
movlpd %xmm0, 0x1c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
void ImPlot::RenderStairs<ImPlot::GetterYs<unsigned int>, ImPlot::TransformerLogLog>(ImPlot::GetterYs<unsigned int> const&, ImPlot::TransformerLogLog const&, ImDrawList&, float, unsigned int)
|
inline void RenderStairs(const Getter& getter, const Transformer& transformer, ImDrawList& DrawList, float line_weight, ImU32 col) {
ImPlotContext& gp = *GImPlot;
if (ImHasFlag(gp.CurrentPlot->Flags, ImPlotFlags_AntiAliased) || gp.Style.AntiAliasedLines) {
ImVec2 p1 = transformer(getter(0));
for (int i = 1; i < getter.Count; ++i) {
ImVec2 p2 = transformer(getter(i));
if (gp.CurrentPlot->PlotRect.Overlaps(ImRect(ImMin(p1, p2), ImMax(p1, p2)))) {
ImVec2 p12(p2.x, p1.y);
DrawList.AddLine(p1, p12, col, line_weight);
DrawList.AddLine(p12, p2, col, line_weight);
}
p1 = p2;
}
}
else {
RenderPrimitives(StairsRenderer<Getter,Transformer>(getter, transformer, col, line_weight), DrawList, gp.CurrentPlot->PlotRect);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, 0x24(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdx, 0x60(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x1cbab8(%rip), %r12 # 0x46a3f0
movq (%r12), %r13
movq 0x28(%r13), %rcx
testb $0x10, 0x5(%rcx)
jne 0x29e954
cmpb $0x1, 0x448(%r13)
jne 0x29ecca
xorpd %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movl 0x8(%r15), %edi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %edi
leal (%rdx,%rdi), %eax
cltd
idivl %edi
movslq %edx, %rax
imulq %r8, %rax
movl (%rsi,%rax), %eax
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd 0x10(%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x40(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rdx
movq 0x28(%r13), %rax
movq %rdx, %rcx
movapd 0x30(%rsp), %xmm2
movhpd 0x1c0(%r13,%rdx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x40(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movsd 0x198(%r13), %xmm0
movhpd 0x1a0(%r13,%rdx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x50(%rsp), %xmm5
movhpd 0xa0(%rax,%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
cvtps2pd %xmm1, %xmm1
subpd %xmm3, %xmm5
movapd %xmm3, %xmm4
mulpd %xmm5, %xmm1
cvtps2pd 0x164(%r13,%rcx), %xmm3
addpd %xmm4, %xmm1
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x70(%rsp)
movl 0x8(%r15), %ecx
cmpl $0x2, %ecx
jl 0x29ee44
movl $0x1, %ebx
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rsi
movslq 0x24(%r15), %rdi
movl 0x20(%r15), %eax
addl %ebx, %eax
cltd
idivl %ecx
leal (%rdx,%rcx), %eax
cltd
idivl %ecx
movslq %edx, %rax
imulq %rdi, %rax
movl (%rsi,%rax), %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x10(%rsp)
movq (%r12), %rbp
movq 0x28(%rbp), %rax
divsd 0x18(%rax), %xmm0
callq 0xe2ca0
movq 0x28(%rbp), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd 0x10(%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x30(%rsp)
movsd 0x1b8(%rbp), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rdx
movq 0x28(%rbp), %rax
movq %rdx, %rcx
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x40(%rsp), %xmm2
movhpd 0x1c0(%rbp,%rdx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movsd 0x198(%rbp), %xmm0
movhpd 0x1a0(%rbp,%rdx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rdx
shlq $0x4, %rcx
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x50(%rsp), %xmm4
movhpd 0xa0(%rax,%rdx), %xmm4 # xmm4 = xmm4[0],mem[0]
movsd 0x98(%rax,%rdx), %xmm2
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
cvtps2pd %xmm1, %xmm1
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
cvtps2pd 0x164(%rbp,%rcx), %xmm3
movsd 0x18(%rax), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm1
movlpd %xmm1, 0x68(%rsp)
movq 0x28(%r13), %rcx
movss 0x74(%rsp), %xmm0
movq %xmm1, %rax
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss 0x2c4(%rcx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x29ecb2
movaps %xmm1, %xmm2
cmpless %xmm0, %xmm2
movaps %xmm2, %xmm3
andps %xmm0, %xmm3
andnps %xmm1, %xmm2
orps %xmm3, %xmm2
ucomiss 0x2bc(%rcx), %xmm2
jbe 0x29ecb2
movss 0x70(%rsp), %xmm1
movd %eax, %xmm2
movaps %xmm1, %xmm3
minss %xmm2, %xmm3
movss 0x2c0(%rcx), %xmm4
ucomiss %xmm3, %xmm4
jbe 0x29ecb2
movaps %xmm2, %xmm3
cmpless %xmm1, %xmm3
movaps %xmm3, %xmm4
andnps %xmm2, %xmm4
andps %xmm1, %xmm3
orps %xmm4, %xmm3
ucomiss 0x2b8(%rcx), %xmm3
jbe 0x29ecb2
movl %eax, 0x28(%rsp)
movss %xmm0, 0x2c(%rsp)
movq 0x60(%rsp), %rbp
movq %rbp, %rdi
leaq 0x70(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movl 0x24(%rsp), %r12d
movl %r12d, %ecx
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq %rbp, %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
movl %r12d, %ecx
movq 0x1cb74e(%rip), %r12 # 0x46a3f0
movss 0xc(%rsp), %xmm0
callq 0xe5ce0
movq 0x68(%rsp), %rax
movq %rax, 0x70(%rsp)
incl %ebx
movl 0x8(%r15), %ecx
cmpl %ecx, %ebx
jl 0x29ea9c
jmp 0x29ee44
leaq 0x70(%rsp), %r12
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movl 0x8(%r15), %esi
leal -0x1(%rsi), %eax
movl %eax, 0x10(%r12)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%r12)
movss 0xc(%rsp), %xmm0
mulss 0xe448d(%rip), %xmm0 # 0x383188
movss %xmm0, 0x18(%r12)
xorps %xmm0, %xmm0
mulsd 0x10(%r15), %xmm0
addsd 0x18(%r15), %xmm0
movq (%r15), %rdi
movl 0x20(%r15), %eax
movslq 0x24(%r15), %r8
cltd
idivl %esi
leal (%rdx,%rsi), %eax
cltd
idivl %esi
movslq %edx, %rax
imulq %r8, %rax
movl (%rdi,%rax), %eax
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x10(%rsp)
divsd 0x18(%rcx), %xmm0
callq 0xe2ca0
movq 0x28(%r13), %rax
movslq (%r14), %rcx
shlq $0x7, %rcx
movsd 0x10(%rsp), %xmm1
divsd 0x98(%rax,%rcx), %xmm1
movapd %xmm0, 0x30(%rsp)
movsd 0x1b8(%r13), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x18(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movapd %xmm1, %xmm0
callq 0xe2ca0
movslq (%r14), %rcx
movq 0x28(%r13), %rdx
movq %rcx, %rax
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movapd 0x40(%rsp), %xmm2
movhpd 0x1c0(%r13,%rcx,8), %xmm2 # xmm2 = xmm2[0],mem[0]
movsd 0x198(%r13), %xmm0
movhpd 0x1a0(%r13,%rcx,8), %xmm0 # xmm0 = xmm0[0],mem[0]
shlq $0x7, %rcx
shlq $0x4, %rax
divpd %xmm2, %xmm1
cvtpd2ps %xmm1, %xmm1
movapd 0x50(%rsp), %xmm4
movhpd 0xa0(%rdx,%rcx), %xmm4 # xmm4 = xmm4[0],mem[0]
movsd 0x98(%rdx,%rcx), %xmm2
movapd 0x10(%rsp), %xmm3
unpcklpd %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0]
subpd %xmm3, %xmm4
cvtps2pd %xmm1, %xmm1
mulpd %xmm4, %xmm1
addpd %xmm3, %xmm1
cvtps2pd 0x164(%r13,%rax), %xmm3
movsd 0x18(%rdx), %xmm4
unpcklpd %xmm2, %xmm4 # xmm4 = xmm4[0],xmm2[0]
subpd %xmm4, %xmm1
mulpd %xmm1, %xmm0
addpd %xmm3, %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x1c(%r12)
addq $0x2b8, %rdx # imm = 0x2B8
movq %r12, %rdi
movq 0x60(%rsp), %rsi
callq 0xe1560
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/JoelLinn[P]py-mahi-gui/thirdparty/mahi-gui/3rdparty/implot/implot_items.cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.