name string | code string | asm string | file string |
|---|---|---|---|
ON_Polyline::IsClosed(double) const | bool ON_Polyline::IsClosed( double tolerance ) const
{
bool rc = false;
const int count = m_count-1;
int i;
if ( count >= 3 )
{
if ( tolerance > 0.0 )
{
if ( m_a[0].DistanceTo(m_a[count]) <= tolerance ) {
for ( i = 1; i < count; i++ ) {
if ( m_a[i].DistanceTo(m_a[0]) > tolera... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jl 0x707480
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
... | /mcneel[P]opennurbs/opennurbs_polyline.cpp |
ON_Polyline::PointAt(double) const | ON_3dPoint ON_Polyline::PointAt( double t ) const
{
const int count = m_count;
int segment_index = 0;
if ( count < 0 ) {
return ON_3dPoint::Origin;
}
else if (count == 1 ) {
return m_a[0];
}
else {
segment_index = (int)floor(t);
if ( segment_index < 0 ) {
segment_index = 0;
//t... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x70773a
movq -0x60(%rbp), %rax
movq 0x375d... | /mcneel[P]opennurbs/opennurbs_polyline.cpp |
ON_Polyline::CreateCircumscribedPolygon(ON_Circle const&, int) | bool ON_Polyline::CreateCircumscribedPolygon(
const ON_Circle& circle,
int side_count
)
{
bool rc = ( circle.IsValid() && side_count >= 3 ) ? true : false;
if ( rc )
{
SetCapacity(side_count+1);
SetCount(side_count+1);
double half_a = ON_PI/side_count;
int i;
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3395a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd5(%rbp)
jne 0x707e3b
jmp 0x707e48
cmpl $0x3, -0x14(%rbp)
setge %a... | /mcneel[P]opennurbs/opennurbs_polyline.cpp |
ON_PolylineCurve::operator=(ON_3dPointArray const&) | ON_PolylineCurve& ON_PolylineCurve::operator=( const ON_3dPointArray& src )
{
m_pline = src;
m_dim = 3;
const int count = src.Count();
m_t.Reserve(count);
m_t.SetCount(count);
int i;
for (i = 0; i < count; i++) {
m_t[i] = (double)i;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rdi
callq 0x327250
movq -0x20(%rbp), %rax
movl $0x3, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x2fe7c0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
ad... | /mcneel[P]opennurbs/opennurbs_polylinecurve.cpp |
ON_PolylineCurve::GetSpanVector(double*) const | bool ON_PolylineCurve::GetSpanVector( // span "knots"
double* s // array of length SpanCount() + 1
) const
{
bool rc = false;
const int count = PointCount();
if ( count >= 1 )
{
memcpy( s, m_t.Array(), count*sizeof(*s) );
rc = true;
}
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x31b240
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jl 0x70a4a7
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
call... | /mcneel[P]opennurbs/opennurbs_polylinecurve.cpp |
ON_PolylineCurve::IsPolyline(ON_SimpleArray<ON_3dPoint>*, ON_SimpleArray<double>*) const | int ON_PolylineCurve::IsPolyline(
ON_SimpleArray<ON_3dPoint>* pline_points,
ON_SimpleArray<double>* pline_t
) const
{
if ( pline_points )
pline_points->SetCount(0);
if ( pline_t )
pline_t->SetCount(0);
int rc = this->PointCount();
if ( rc >= 2 )
{
if ( pline_points )
pline_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x70a65e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2fc980
cmpq $0x0, -0x18(%rbp)
je 0x70a670
movq -0x18(%rbp), %rdi
xorl %esi, %esi
... | /mcneel[P]opennurbs/opennurbs_polylinecurve.cpp |
ON_PolylineCurve::IsInPlane(ON_Plane const&, double) const | bool
ON_PolylineCurve::IsInPlane(
const ON_Plane& plane, // plane to test
double tolerance // tolerance to use when checking linearity
) const
{
bool rc = false;
ON_NurbsCurve nurbs_curve;
nurbs_curve.m_dim = m_dim;
nurbs_curve.m_is_rat = 0;
nurbs_curve.m_order = 2;
nurbs_curve.m_cv_count ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x324190
movq -0x78(%rbp), %rdi
movl 0x40(%rdi), %eax
movl %eax, -0x50(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x2... | /mcneel[P]opennurbs/opennurbs_polylinecurve.cpp |
ON_PolylineCurve::IsContinuous(ON::continuity, double, int*, double, double, double, double, double) const | bool ON_PolylineCurve::IsContinuous(
ON::continuity desired_continuity,
double t,
int* hint, // default = nullptr,
double point_tolerance, // default=ON_ZERO_TOLERANCE
double d1_tolerance, // default==ON_ZERO_TOLERANCE
double d2_tolerance, // default==ON_ZERO_TOLERANCE
double cos_angle_tole... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm4, -0x40(%rbp)
movsd %xmm5, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movb $0x1, -0x... | /mcneel[P]opennurbs/opennurbs_polylinecurve.cpp |
ON_PolylineCurve::Trim(ON_Interval const&) | bool ON_PolylineCurve::Trim( const ON_Interval& domain )
{
int segment_count = m_t.Count()-1;
if ( segment_count < 1 || m_t.Count() != m_pline.Count() || !domain.IsIncreasing() )
return false;
const ON_Interval original_polyline_domain = Domain();
if ( !original_polyline_domain.IsIncreasing() )
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp # imm = 0x4B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x278(%rbp)
addq $0x28, %rdi
callq 0x334f30
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jl 0x70c422
movq -0x278(%rbp), %rdi
addq $0x28, %rdi
callq 0x33... | /mcneel[P]opennurbs/opennurbs_polylinecurve.cpp |
ON_PolylineCurve::SetArcLengthParameterization(double) | void ON_PolylineCurve::SetArcLengthParameterization(double tolerance)
{
double d, mind = tolerance;
m_t[0] = 0;
const int count = m_pline.Count();
for (int i = 1; i < count; i++)
{
d = (m_pline[i] - m_pline[i - 1]).Length();
if (d < mind)
d = mind;
if (d < fabs(m_t[i - 1]) * 1e-5)
d = ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
addq $0x28, %rdi
xorl %esi, %esi
callq 0x30bfd0
movq -0x48(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x10, %rdi
callq 0... | /mcneel[P]opennurbs/opennurbs_polylinecurve.cpp |
PostEffectTypeString(ON_PostEffect::Types) | static const wchar_t* PostEffectTypeString(ON_PostEffect::Types type)
{
switch (type)
{
case ON_PostEffect::Types::Early: return ON_RDK_PEP_TYPE_EARLY;
case ON_PostEffect::Types::ToneMapping: return ON_RDK_PEP_TYPE_TONE_MAPPING;
case ON_PostEffect::Types::Late: return ON_RDK_PEP_TYPE_LATE;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x70e66c
jmp 0x70e658
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x70e679
jmp 0x70e662
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x70e686
jmp 0x70e693
leaq 0x1f7ec9(%rip), %rax # 0x90653c
... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffect::CImpl::PepNode() const | ON_XMLNode* ON_PostEffect::CImpl::PepNode(void) const
{
if (nullptr != _collection)
{
ON_XMLNode& post_effects_node = _collection->WritablePostEffectsNode();
ON_XMLNode* pep_type_node = GetPostEffectTypeNode(post_effects_node, _type);
if (nullptr == pep_type_node)
return nullptr;
ON_XMLNode* ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x70e97c
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x318c20
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl 0x28(%rax), %es... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffect::CImpl::SetPropertyValue(wchar_t const*, ON_XMLVariant const&) const | void ON_PostEffect::CImpl::SetPropertyValue(const wchar_t* name, const ON_XMLVariant& value) const
{
auto* pep_node = PepNode();
if (nullptr != pep_node)
{
pep_node->SetProperty(ON_XMLProperty(name, value));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31cbc0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x70ec5e
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq ... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffect::ON_PostEffect(ON_PostEffect const&) | ON_PostEffect::ON_PostEffect(const ON_PostEffect& pep)
{
_impl = new CImpl(nullptr, pep.LocalName(), pep.Id(), pep.Type());
operator = (pep);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x36d8d1(%rip), %rcx # 0xa7c610
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x30, %edi
callq 0x3003f0
movq %rax, -0x40(%rbp)
movb $0x1, -0x35(%rbp)
movq -0x10(%rbp), %rsi
movq (%rsi... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffect::GetParameter(wchar_t const*) const | ON_XMLVariant ON_PostEffect::GetParameter(const wchar_t* param_name) const
{
ON_XMLVariant value;
value.SetNull();
const ON_XMLNode* pep_node = _impl->PepNode();
if (nullptr != pep_node)
{
const ON_XMLNode* pep_param_node = pep_node->GetNamedChild(ON_RDK_PEP_PARAMS);
if (nullptr != pep_param_node)
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x31f050
movq -0x58(%rbp), %rdi
callq 0x313160
jmp 0x70f57e
movq -0x60(... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffect::GetAllParameters(ON_PostEffectParams&) const | bool ON_PostEffect::GetAllParameters(ON_PostEffectParams& params) const
{
const ON_XMLNode* pep_node = _impl->PepNode();
if (nullptr == pep_node)
return false;
const ON_XMLNode* pep_param_node = pep_node->GetNamedChild(ON_RDK_PEP_PARAMS);
if (nullptr == pep_param_node)
return false;
params = ON_Post... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31cbc0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x70f7ff
movb $0x0, -0x1(%rbp)
jmp 0x70f86b
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
leaq 0x1f6cef(%rip),... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffect::XMLNode() | ON_XMLNode& ON_PostEffect::XMLNode(void)
{
auto* pep_node = _impl->PepNode();
if (nullptr != pep_node)
return *pep_node;
// Should never get here.
ON_ASSERT(false);
return g_panic_node;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31cbc0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x70f93f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x70f96d
xorl %edi, %edi
leaq 0x1f6d28(%rip), %rsi # 0x906670
movl $... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffects::CImpl::PostEffectsNode() const | ON_XMLNode& ON_PostEffects::CImpl::PostEffectsNode(void) const
{
ON_XMLNode* post_effects_node = Node().CreateNodeAtPath(XMLPathPeps());
if (nullptr != post_effects_node)
return *post_effects_node;
// Should never get here.
ON_ASSERT(false);
return g_panic_node;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fe780
movq %rax, -0x20(%rbp)
callq 0x70fb70
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x150(%rax)
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x70fb34
movq -0x18(%rbp), %rax
movq... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffects::CImpl::Populate(ON_PostEffect::Types) const | void ON_PostEffects::CImpl::Populate(ON_PostEffect::Types type) const
{
const ON_XMLNode* pep_type_node = GetPostEffectTypeNode(PostEffectsNode(), type);
if (nullptr == pep_type_node)
return;
auto it = pep_type_node->GetChildIterator();
ON_XMLNode* pep_node = it.GetNextChild();
while (nullptr != pep_nod... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x31d140
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x70ea20
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x70fc5b
jmp 0x70fed7
movq ... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffects::AddPostEffect(ON_PostEffect::Types, ON_UUID_struct const&, wchar_t const*, ON_PostEffectParams const&, bool, bool, bool) | bool ON_PostEffects::AddPostEffect(ON_PostEffect::Types type, const ON_UUID& id,
const wchar_t* local_name, const ON_PostEffectParams& params,
bool is_listable, bool listable_on, bool listable_shown)
{
if (ON_PostEffect::Types::Unset == type)
r... | pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp # imm = 0x670
movl %r9d, %eax
movq %rcx, -0x630(%rbp)
movq %rdx, -0x628(%rbp)
movl %esi, %r9d
movq -0x630(%rbp), %rsi
movq %rdi, %r10
movq -0x628(%rbp), %rdi
movb %al, %dl
movb 0x18(%rbp), %al
movb 0x10(%rbp), %cl
movq %r10, -0x10(%rbp)
movl %r9d, -0x14(%rbp)
movq... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffects::GetSelectedPostEffect(ON_PostEffect::Types, ON_UUID_struct&) const | bool ON_PostEffects::GetSelectedPostEffect(ON_PostEffect::Types type, ON_UUID& id_out) const
{
const ON_XMLNode* pep_type_node = GetPostEffectTypeNode(_impl->PostEffectsNode(), type);
if (nullptr != pep_type_node)
{
ON_XMLProperty* prop = pep_type_node->GetNamedProperty(ON_RDK_PEP_SELECTION);
if (nullptr ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31d140
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x70ea20
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x710f70
movq -0x28(%rbp), %r... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_PostEffectParams::CImpl::AsXMLParameters() const | const ON_XMLParameters& AsXMLParameters(void) const
{
if (nullptr == _params)
{
_params = new ON_XMLParameters(_node);
}
return *_params;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq 0xe8(%rcx), %rax
jne 0x71127b
movl $0x10, %edi
callq 0x3003f0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x3075e0
jmp 0x71124e
movq -0x20(%rbp), %r... | /mcneel[P]opennurbs/opennurbs_post_effects.cpp |
ON_SimpleArray<ON_PostEffect const*>::Append(ON_PostEffect const* const&) | void ON_SimpleArray<T>::Append( const T& x )
{
const T* p = &x;
if ( m_count == m_capacity )
{
const int newcapacity = NewCapacity();
if ( p >= m_a && p < (m_a + m_capacity) )
{
// 26 Sep 2005 Dale Lear
// x is in the block of memory about to be reallocated.
void* temp = onmalloc(s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x7117b4
movq -0x30(%rbp), %rdi
callq 0x306740
movq -0x30(%rbp), %rcx
movl %eax, -0x1c(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_PostEffect*>::Insert(int, ON_PostEffect* const&) | void ON_SimpleArray<T>::Insert( int i, const T& x )
{
if( i >= 0 && i <= m_count )
{
const T* p = &x;
if ( m_count == m_capacity )
{
if (&x >= m_a && &x < (m_a + m_capacity))
{
// x is in the block of memory about to be reallocated.
void* temp = onmalloc(sizeof(T));
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x711990
movq -0x38(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x711990
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq ... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_PostEffect const*>::Move(int, int, int) | void ON_SimpleArray<T>::Move( int dest_i, int src_i, int ele_cnt )
{
// private function for moving blocks of array memory
// caller is responsible for updating m_count.
if ( ele_cnt <= 0 || src_i < 0 || dest_i < 0 || src_i == dest_i ||
src_i + ele_cnt > m_count || dest_i > m_count )
return;
int ca... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x711ea2
cmpl $0x0, -0x10(%rbp)
jl 0x711ea2
cmpl $0x0, -0xc(%rbp)
jl 0x711ea2
movl -0x10(%rbp), %eax
cmpl -0xc(%rb... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_PostEffect const*>::NewCapacity() const | int ON_SimpleArray<T>::NewCapacity() const
{
// Note:
// This code appears in ON_SimpleArray<T>::NewCapacity()
// and ON_ClassArray<T>::NewCapacity(). Changes made to
// either function should be made to both functions.
// Because this code is template code that has to
// support dynamic linking... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x10000000, -0x18(%rbp) # imm = 0x10000000
movslq 0x10(%rax), %rax
shlq $0x3, %rax
cmpq $0x10000000, %rax # imm = 0x10000000
jbe 0x7120a2
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x7120ca
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_ProgressStepCounter::Create(ON_ProgressReporter*, unsigned int, double, double, unsigned int) | ON_ProgressStepCounter ON_ProgressStepCounter::Create(
ON_ProgressReporter* progress_reporter,
unsigned int step_count,
double progress_interval_start,
double progress_interval_finish,
unsigned int maximum_progress_reports
)
{
if (nullptr != progress_reporter
&& step_count > 0
&& 0.0 <= progress_i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x7125d4
cmpl $0x0, -0xc(%rbp)
jbe 0x7125d4
movsd -0x18(%rbp), %xmm0
xor... | /mcneel[P]opennurbs/opennurbs_progress_reporter.cpp |
ON_Quaternion::SetRotation(double, ON_3dVector const&) | void ON_Quaternion::SetRotation(double angle, const ON_3dVector& axis)
{
double s = axis.Length();
s = (s > 0.0) ? sin(0.5*angle)/s : 0.0;
a = cos(0.5*angle);
b = s*axis.x;
c = s*axis.y;
d = s*axis.z;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x306790
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x712b47
movsd 0x1c2e2f(%rip)... | /mcneel[P]opennurbs/opennurbs_quaternion.cpp |
ON_Quaternion::Slerp(ON_Quaternion, ON_Quaternion, double) | ON_Quaternion ON_Quaternion::Slerp(ON_Quaternion q0, ON_Quaternion q1, double t)
{
ON_Quaternion q;
if ( t <= 0.5 )
{
q = q0.Inverse()*q1;
q = q0*ON_Quaternion::Pow(q,t);
}
else
{
q = q1.Inverse()*q0;
q = q1*ON_Quaternion::Pow(q,1.0-t);
}
return q;
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x168(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
leaq 0x30(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movsd %xmm0, -0x8(%rbp)
callq 0x32a160
movsd 0x1c276c(%rip), %xmm0 # 0x8d5960
ucomisd -0x8(%... | /mcneel[P]opennurbs/opennurbs_quaternion.cpp |
ON_Quaternion::SetRotation(ON_Plane const&, ON_Plane const&) | void ON_Quaternion::SetRotation(const ON_Plane& plane0, const ON_Plane& plane1 )
{
double m[3][3], r, s;
double* q;
int i,j,k;
// set m[][] = rotation matrix (acting on the left)
m[0][0] = plane1.xaxis.x*plane0.xaxis.x
+ plane1.yaxis.x*plane0.yaxis.x
+ plane1.zaxis.x*plane0.zaxis.x;
m[0... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq -0x10(%rbp), %rax... | /mcneel[P]opennurbs/opennurbs_quaternion.cpp |
ON_Quaternion::GetRotation(double&, ON_3dVector&) const | bool ON_Quaternion::GetRotation(double& angle, ON_3dVector& axis) const
{
const double s = Length();
angle = (s > ON_DBL_MIN) ? 2.0*acos(a/s) : 0.0;
axis.x = b;
axis.y = c;
axis.z = d;
return (axis.Unitize() && s > ON_DBL_MIN);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x300770
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x1e7035(%rip), %xmm1 # 0x8fba58
ucomisd %xmm1, %xmm0
jbe 0x714a51
movq -0x28(%rbp), %rax
... | /mcneel[P]opennurbs/opennurbs_quaternion.cpp |
ON_Quaternion::IsValid() const | bool ON_Quaternion::IsValid() const
{
return ((ON_IS_VALID(a) && ON_IS_VALID(b) && ON_IS_VALID(c) && ON_IS_VALID(d)) ? true : false);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd (%rax), %xmm0
xorl %eax, %eax
movsd 0x1bea7a(%rip), %xmm1 # 0x8d3768
ucomisd %xmm1, %xmm0
movb %al, -0x9(%rbp)
jbe 0x714dbb
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movsd 0x1c98bf(%rip), %xmm0 # 0x8de5c8
ucomisd (%rcx)... | /mcneel[P]opennurbs/opennurbs_quaternion.cpp |
on_random_number_seed | void on_random_number_seed(ON__UINT32 s,ON_RANDOM_NUMBER_CONTEXT* randcontext)
{
ON__UINT32 i, u;
#if defined(ON_COMPILER_MSC)
#pragma ON_PRAGMA_WARNING_PUSH
#pragma ON_PRAGMA_WARNING_DISABLE_MSC( 4127 ) // warning C4127: conditional expression is constant
#endif
if ( N*sizeof(randcontext->mt[0]) != sizeof(randcon... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movabsq $0xffffffff, %rcx # imm = 0xFFFFFFFF
andq %rcx, %rax
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, -0x14(%rbp)
cmpl $0x270, -0x14(%rbp) # imm = 0x270
jae 0x715d... | /mcneel[P]opennurbs/opennurbs_rand.cpp |
ON_RandomNumberGenerator::RandomSignedInteger(int, int) | int ON_RandomNumberGenerator::RandomSignedInteger(int i0, int i1)
{
const ON__UINT32 r = RandomNumber();
const ON__UINT32 delta = (i0 < i1) ? ((unsigned)(i1 - i0)) : ((unsigned)(i0 - i1));
return
(0xFFFFFFFFU == delta)
? ((int)r) // avoid delta+1 overflow and crash
: (((i0 < i1) ? i0 : i1) + ((int)(r ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x319e20
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x716261
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x71626a
movl -0xc(... | /mcneel[P]opennurbs/opennurbs_rand.cpp |
Swap4(unsigned long, unsigned int*, unsigned int*) | static void Swap4(size_t count, ON__UINT32* a, ON__UINT32* b)
{
ON__UINT32 t;
while (count--)
{
t = *a;
*a = *b;
*b = t;
a++;
b++;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpq $0x0, %rax
je 0x71660d
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp... | /mcneel[P]opennurbs/opennurbs_rand.cpp |
ON_RenderChannels::SetMode(ON_RenderChannels::Modes) | void ON_RenderChannels::SetMode(Modes m)
{
ON_wString s = ON_RDK_RCH_MODE_AUTOMATIC;
if (Modes::Custom == m)
s = ON_RDK_RCH_MODE_CUSTOM;
m_impl->SetParameter(XMLPath(), ON_RDK_RCH_MODE, s);
} | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0x1efb00(%rip), %rsi # 0x9068a8
callq 0x313d70
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jne 0x716ddc
leaq 0x1ce94a(%rip), %rsi # ... | /mcneel[P]opennurbs/opennurbs_render_channels.cpp |
GetSortedSemicolonDelimitedString(ON_SimpleArray<ON_UUID_struct> const&) | static ON_wString GetSortedSemicolonDelimitedString(const ON_SimpleArray<ON_UUID>& chan)
{
ON_wString s;
ON_ClassArray<ON_wString> a;
for (int i = 0; i < chan.Count(); i++)
{
ON_UuidToString(chan[i], s);
a.Append(s);
}
a.QuickSort(ON_CompareIncreasing);
s = L"";
for (int i = 0; i < a.Count()... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3390e0
leaq -0x30(%rbp), %rdi
callq 0x334380
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
c... | /mcneel[P]opennurbs/opennurbs_render_channels.cpp |
ON_Environment::ProjectionFromString(wchar_t const*) | ON_Environment::BackgroundProjections ON_Environment::ProjectionFromString(const wchar_t* wsz) // Static.
{
if (0 == on_wcsicmp(ON_ENVIRONMENT_PROJECTION_PLANAR, wsz)) return BackgroundProjections::Planar;
if (0 == on_wcsicmp(ON_ENVIRONMENT_PROJECTION_SPHERICAL, wsz)) return BackgroundProjections::Spheri... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x1cd32d(%rip), %rdi # 0x8e53f4
callq 0x33a950
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7180e0
movl $0x0, -0x4(%rbp)
jmp 0x718221
movq -0x10(%rbp), %rsi
leaq 0x1eed5d(%rip), %rdi # 0x906e48
callq 0x33a950
m... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContentPrivate::ON_RenderContentPrivate(ON_RenderContent&, wchar_t const*) | ON_RenderContentPrivate::ON_RenderContentPrivate(ON_RenderContent& rc, const wchar_t* kind)
:
m_node(kind),
m_render_content(rc)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x36658d(%rip), %rax # 0xa7e910
addq $0x10, %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x321830
movq -0x20(%... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContentPrivate::AddChild(ON_RenderContent&) | bool ON_RenderContentPrivate::AddChild(ON_RenderContent& child)
{
if ((nullptr != child._private->m_model) || (nullptr != child._private->m_parent) || (nullptr != child._private->m_next_sibling))
return false;
if (nullptr == m_first_child)
{
m_first_child = &child;
}
else
{
ON_RenderContent* la... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jne 0x718d87
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rcx
xorl %eax, %eax
cmpq 0x100(%rcx), %rax
jne 0... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContentPrivate::FindLastChild() const | ON_RenderContent* ON_RenderContentPrivate::FindLastChild(void) const
{
ON_RenderContent* result = nullptr;
ON_RenderContent* candidate = m_first_child;
while (nullptr != candidate)
{
result = candidate;
candidate = candidate->_private->m_next_sibling;
}
return result;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x10(%rbp)
movq 0x108(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x718f97
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq 0x110(%rax), %rax
movq %rax, -0x1... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContentPrivate::ChangeChild(ON_RenderContent*, ON_RenderContent*) | bool ON_RenderContentPrivate::ChangeChild(ON_RenderContent* old_child, ON_RenderContent* new_child)
{
if (nullptr == old_child)
return false;
if (old_child == m_first_child)
{
if (nullptr != new_child)
{
m_first_child = new_child;
}
else
{
m_first_child = old_child->_private->... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x7190bd
movb $0x0, -0x1(%rbp)
jmp 0x7191da
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x108(%rcx), %rax
jne 0... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContentPrivate::SetChild(ON_RenderContent*, wchar_t const*) | bool ON_RenderContentPrivate::SetChild(ON_RenderContent* child, const wchar_t* child_slot_name)
{
std::lock_guard<std::recursive_mutex> lg(m_mutex);
if (nullptr != child)
{
if (nullptr != child->_private->m_model)
return false;
if (nullptr != child->_private->m_parent)
return false;
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x150(%rbp)
addq $0x118, %rsi # imm = 0x118
leaq -0x28(%rbp), %rdi
callq 0x328d40
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x719431
mo... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContentPrivate::BuildXMLHierarchy(ON_RenderContent const&, ON_XMLNode&) | void ON_RenderContentPrivate::BuildXMLHierarchy(const ON_RenderContent& rc, ON_XMLNode& node) // Static.
{
// Recursively builds 'node' from the tree structure of the XML nodes in 'rc' and its children.
node = rc._private->m_node;
auto* child_rc = rc._private->m_first_child;
while (nullptr != child_rc)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rdi
callq 0x30c9a0
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq 0x108(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je ... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContentPrivate::SetModel(ON_RenderContent const&, ONX_Model&) | void ON_RenderContentPrivate::SetModel(const ON_RenderContent& rc, ONX_Model& model) // Static.
{
rc._private->m_model = &model;
auto it = rc.GetChildIterator();
ON_RenderContent* child_rc = nullptr;
while (nullptr != (child_rc = it.GetNextChild()))
{
SetModel(*child_rc, model);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rsi
movq (%rsi), %rax
leaq -0x20(%rbp), %rdi
callq *0x178(%rax)
movq $0x0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x312cb0
... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::Cast(ON_Object const*) | ON_RenderContent::ON_RenderContent(const wchar_t* kind)
:
ON_ModelComponent(ON_ModelComponent::Type::RenderContent)
{
_private = new (_PRIVATE) ON_RenderContentPrivate(*this, kind); PRIVATE_CHECK(ON_RenderContentPrivate);
// Set a unique instance id.
ON_UUID uuid;
ON_CreateUuid(uuid);
SetId(uuid);
// ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x719ac3
movq -0x8(%rbp), %rdi
movq 0x364112(%rip), %rsi # 0xa7dbc0
callq 0x32e120
testb $0x1, %al
jne 0x719ab9
jmp 0x719ac3
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x719acb
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp ... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::CopyFrom(ON_Object const*) | ON_RenderContent::ON_RenderContent(const wchar_t* kind)
:
ON_ModelComponent(ON_ModelComponent::Type::RenderContent)
{
_private = new (_PRIVATE) ON_RenderContentPrivate(*this, kind); PRIVATE_CHECK(ON_RenderContentPrivate);
// Set a unique instance id.
ON_UUID uuid;
ON_CreateUuid(uuid);
SetId(uuid);
// ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::Internal_DeepCopy() const | ON_RenderContent::ON_RenderContent(const wchar_t* kind)
:
ON_ModelComponent(ON_ModelComponent::Type::RenderContent)
{
_private = new (_PRIVATE) ON_RenderContentPrivate(*this, kind); PRIVATE_CHECK(ON_RenderContentPrivate);
// Set a unique instance id.
ON_UUID uuid;
ON_CreateUuid(uuid);
SetId(uuid);
// ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
| /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::GetParameter(wchar_t const*) const | ON_XMLVariant ON_RenderContent::GetParameter(const wchar_t* name) const
{
std::lock_guard<std::recursive_mutex> lg(_private->m_mutex);
ON_XMLVariant value;
value.SetNull();
// Try to get the new V8 parameter section.
const ON_XMLNode* node = _private->m_node.GetNamedChild(ON_RENDER_CONTENT_PARAMETERS_V8);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x90(%rax), %rsi
addq $0x118, %rsi # imm = 0x118
leaq -0x20(%rbp), %rdi
callq 0x328d... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::ChildSlotOn(wchar_t const*) const | bool ON_RenderContent::ChildSlotOn(const wchar_t* child_slot_name) const
{
const auto s = ON_wString(child_slot_name) + L"-" MAT_POSTFIX_ON;
return GetParameter(s).AsBool();
} | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x313d70
movq -0x130(%rbp), %rsi
leaq 0x1e5dc4(%rip), %rdx # 0x901044
leaq -0x18... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::ChildSlotAmount(wchar_t const*, double) const | double ON_RenderContent::ChildSlotAmount(const wchar_t* child_slot_name, double default_value) const
{
// This is complicated. See https://mcneel.myjetbrains.com/youtrack/issue/RH-58417
// Try to get the new double amount value in the range 0..1.
auto s = ON_wString(child_slot_name) + L"-" MAT_POSTFIX_DOUBLE_AMO... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x258(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x313d70
movq -0x250(%rbp), %rsi
leaq 0x1ebc23(%rip), %r... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::SetChildSlotAmount(double, wchar_t const*) | bool ON_RenderContent::SetChildSlotAmount(double amount, const wchar_t* child_slot_name)
{
const auto s = ON_wString(child_slot_name) + L"-" MAT_POSTFIX_DOUBLE_AMOUNT;
return SetParameter(s, amount / 100.0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x313d70
movq -0x138(%rbp), %rsi
leaq 0x1eb8f3(%rip), %rdx... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ON_RenderContent::XML(bool) const | ON_wString ON_RenderContent::XML(bool recursive) const
{
ON_XMLNode* node = &_private->m_node;
if (recursive)
{
node = ON_RenderContentPrivate::NewXMLNodeRecursive(*this);
}
const ON__UINT32 logical_count = node->WriteToStream(nullptr, 0);
auto* stream = new wchar_t[size_t(logical_count) + 1];
node-... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x90(%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
testb $0x1... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
ONX_Model::AddRenderEnvironment(wchar_t const*) | int ONX_Model::AddRenderEnvironment(const wchar_t* candidate_name)
{
if (!ON_ModelComponent::IsValidComponentName(candidate_name))
return ON_UNSET_INT_INDEX;
ON_RenderEnvironment env;
env.SetTypeId(ON_RenderContentType_BasicEnvironment);
const ON_wString env_name = m_manifest.UnusedName(env.ComponentType(... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2a8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x307610
testb $0x1, %al
jne 0x720177
movl $0x80000001, -0x4(%rbp) # imm = 0x80000001
jmp 0x720396
leaq -0x258(%rbp), %rdi
movq ... | /mcneel[P]opennurbs/opennurbs_render_content.cpp |
CreateNewON_RevSurface() | void ON_RevSurface::DestroyRuntimeCache( bool bDelete )
{
ON_Surface::DestroyRuntimeCache(bDelete);
if ( 0 != m_curve )
m_curve->DestroyRuntimeCache(bDelete);
// 15 August 2003 Dale Lear
// Added the call to destroy m_bbox.
m_bbox.Destroy();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xa0, %edi
callq 0x3003f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x325470
jmp 0x721133
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::Cast(ON_Object const*) | void ON_RevSurface::DestroyRuntimeCache( bool bDelete )
{
ON_Surface::DestroyRuntimeCache(bDelete);
if ( 0 != m_curve )
m_curve->DestroyRuntimeCache(bDelete);
// 15 August 2003 Dale Lear
// Added the call to destroy m_bbox.
m_bbox.Destroy();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7211e3
movq -0x8(%rbp), %rdi
movq 0x35b69a(%rip), %rsi # 0xa7c868
callq 0x32e120
testb $0x1, %al
jne 0x7211d9
jmp 0x7211e3
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x7211eb
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp ... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::Duplicate() const | void ON_RevSurface::DestroyRuntimeCache( bool bDelete )
{
ON_Surface::DestroyRuntimeCache(bDelete);
if ( 0 != m_curve )
m_curve->DestroyRuntimeCache(bDelete);
// 15 August 2003 Dale Lear
// Added the call to destroy m_bbox.
m_bbox.Destroy();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::Transform(ON_Xform const&) | bool ON_RevSurface::Transform( const ON_Xform& xform )
{
DestroyRuntimeCache();
TransformUserData(xform);
bool rc = (m_curve) ? m_curve->Transform(xform) : false;
ON_3dVector X, Y, Z;
Z = m_axis.Tangent();
X.PerpendicularTo( Z );
X.Unitize();
Y = ON_CrossProduct( Z, X );
if ( !m_axis.Transform(xform) ... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x178(%rbp)
movq (%rdi), %rax
movl $0x1, %esi
callq *0xb8(%rax)
movq -0x178(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x313470
movq -0x178(%rbp), %rax
cmpq $0x0, 0x10(%rax)... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::IsoArc(double) const | ON_Arc ON_RevSurface::IsoArc(
double curve_parameter
) const
{
for (;;)
{
if (nullptr == m_curve)
break;
// 8 December 2003 Chuck - fix iso extraction bug
// when m_angle[0] != 0.
ON_Circle circle;
ON_3dPoint P = m_curve->PointAt(curve_parameter);
if (false == P.IsValid())
br... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq -0x1b0(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x7... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::Reverse(int) | bool ON_RevSurface::Reverse( int dir )
{
bool rc = false;
if ( m_bTransposed )
dir = dir ? 0 : 1;
if ( dir == 0 )
{
m_axis.Reverse();
double a0 = m_angle[0];
double a1 = m_angle[1];
m_angle.Set( 2.0*ON_PI - a1, 2.0*ON_PI - a0 );
m_t.Reverse();
rc = true;
}
else if ( dir == 1 && m... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0xd(%rbp)
testb $0x1, 0x68(%rax)
je 0x725a84
movl -0xc(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rb... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::GetParameterTolerance(int, double, double*, double*) const | bool ON_RevSurface::GetParameterTolerance( // returns tminus < tplus: parameters tminus <= s <= tplus
int dir, // 0 gets first parameter, 1 gets second parameter
double t, // t = parameter in domain
double* tminus, // tminus
double* tplus // tplus
) const
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x29(%rbp)
testb $0x1, 0x68(%rax)
je 0x726241
movl -0xc(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::GetBBox(double*, double*, bool) const | bool ON_RevSurface::GetBBox( // returns true if successful
double* boxmin, // boxmin[dim]
double* boxmax, // boxmax[dim]
bool bGrowBox // true means grow box
) const
{
bool rc = m_bbox.IsValid();
if ( !rc )
{
ON_BoundingBox bbox, cbox, abox;
rc = m_curve->GetBoundingBo... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x248(%rbp)
addq $0x70, %rdi
callq 0x3137a0
andb $0x1, %al
movb %al, -0x1a(%rbp)
testb $0x1, -0x1... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RevSurface::IsConical(ON_Cone*, double) const | bool ON_RevSurface::IsConical(
ON_Cone* cone,
double tolerance
) const
{
ON_Cone c;
ON_Line line;
double r[2] = {0.0,0.0};
double h = 0.0;
if ( !ON_IsValid(tolerance) || tolerance <= 0.0 )
tolerance = ON_ZERO_TOLERANCE;
if ( !ON__IsCylConeHelper(m_axis,m_curve,tolerance,c.plane,line,r,... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x334110
leaq -0xe0(%rbp), %rdi
callq 0x31c660
jmp 0x72a3cd
xorps %xmm0, %xmm0
movaps %xmm0, -0x100(%rb... | /mcneel[P]opennurbs/opennurbs_revsurface.cpp |
ON_RTreeMemPool::DeallocateAll() | void ON_RTreeMemPool::DeallocateAll()
{
struct Blk* p = m_blk_list;
if (nullptr != p)
{
m_nodes = nullptr;
m_list_nodes = nullptr;
m_buffer = nullptr;
m_buffer_capacity = 0;
m_blk_list = nullptr;
m_sizeof_blk = 0;
m_sizeof_heap = 0;
while (p)
{
struct Blk* next = p->m_ne... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x72c1d6
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_RTreeIterator::PushChildren(ON_RTreeIterator::StackElement*, bool) | bool ON_RTreeIterator::PushChildren(StackElement* sp, bool bFirstChild )
{
StackElement* spmax = &m_stack[0] + MAX_STACK;
const ON_RTreeNode* node = sp->m_node;
m_sp = 0;
// push first leaf converted by this node onto the stack
while( 0 != node && node->m_level >= 0 && node->m_count > 0 )
{
if ( 0 == n... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x200, %rcx # imm = 0x200
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx,... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_SubDRTree::CreateSubDEmptyRTree(ON_SubD const&) | bool ON_SubDRTree::CreateSubDEmptyRTree(
const ON_SubD& subd
)
{
// ShareContentsFrom() increments the reference count on m_subdimple_sp
// so vertex pointers one this RTree's nodes will be valid for the duration
// of the rtree's existence.
m_subd.ShareContentsFrom(const_cast<ON_SubD&>(subd));
this->Remove... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0x31e510
movq -0x18(%rbp), %rdi
callq 0x317b30
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_SubDRTree::FindMarkedVertexAtPoint(ON_3dPoint, double) const | const ON_SubDVertex* ON_SubDRTree::FindMarkedVertexAtPoint(
const ON_3dPoint P,
const double distance_tolerance
) const
{
ON_SubDRTreeVertexFinder vf;
vf = ON_SubDRTreeVertexFinder::Create(P, false);
ON_BoundingBox rbox;
const ON_3dVector rtol(distance_tolerance, distance_tolerance, distance_tolerance);
... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
leaq 0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3352e0
movq -0x110(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_RTree::Remove(double const*, double const*, void*) | bool ON_RTree::Remove(const double a_min[ON_RTree_NODE_DIM], const double a_max[ON_RTree_NODE_DIM], void* a_dataId)
{
bool rc = false;
if ( 0 != m_root )
{
ON_RTreeBBox rect;
memcpy(rect.m_min,a_min,sizeof(rect.m_min));
memcpy(rect.m_max,a_max,sizeof(rect.m_max));
if ( rect.m_min[0] <= rect.m_max[... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb $0x0, -0x21(%rbp)
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x72edff
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
SearchHelper(ON_RTreeNode const*, ON_Line const*, ON_RTreeSearchResultCallback&) | static
bool SearchHelper(const ON_RTreeNode* a_node, const ON_Line* a_line, ON_RTreeSearchResultCallback& a_result)
{
// NOTE:
// Some versions of ON_RTree::Search shrink a_rect as the search progresses.
int i, count;
if ((count = a_node->m_count) > 0)
{
const ON_RTreeBranch* branch = a_node->m_branch... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jle 0x72f38b
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30df70
testb $0x1,... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
SearchHelper(ON_RTreeNode const*, ON_RTreeCapsule*, ON_RTreeSearchResultCallback&) | static
bool SearchHelper(const ON_RTreeNode* a_node, struct ON_RTreeCapsule* a_capsule, ON_RTreeSearchResultCallback& a_result )
{
// NOTE:
// Some versions of ON_RTree::Search shrink a_sphere as the search progresses.
int i, count;
double r[2];
if ( (count = a_node->m_count) > 0 )
{
const ON_RTre... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jle 0x72fecd
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30df70
testb $0x1,... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_RTree::Search(double const*, double const*, ON_SimpleArray<void*>&) const | bool ON_RTree::Search(const double a_min[ON_RTree_NODE_DIM], const double a_max[ON_RTree_NODE_DIM],
ON_SimpleArray<void*>& a_result
) const
{
if ( 0 == m_root )
return false;
ON_RTreeBBox rect;
memcpy(rect.m_min,a_min,sizeof(rect.m_min));
memcpy(rect.m_m... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x60(%rbp)
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x73032d
movb $0x0, -0x1(%rbp)
jmp 0x73037c
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_RTree::Search2d(double const*, double const*, ON_RTreeSearchResult&) const | bool ON_RTree::Search2d(const double a_min[2], const double a_max[2],
ON_RTreeSearchResult& a_result ) const
{
if ( 0 == m_root )
return false;
ON_RTreeBBox rect;
memcpy(rect.m_min,a_min,2*sizeof(a_min[0]));
rect.m_min[2] = 0.0;
memcpy(rect.m_max,a_max,2*sizeof(a_max[0]));
rec... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x60(%rbp)
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x7305fd
movb $0x0, -0x1(%rbp)
jmp 0x73064c
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
PairSearchHelper(ON_RTreeNode const*, ON_RTreeNode const*, ON_RTreePairSearchResult*) | static void PairSearchHelper( const ON_RTreeNode* a_nodeA, const ON_RTreeNode* a_nodeB, ON_RTreePairSearchResult* a_result )
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchA, *branchAmax, *branchB, *branchBmax;
branchA = a_nodeA->m_branch;
branchAmax = branchA + a_nodeA->m_count;
branc... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp)... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
SingleTreeSearchHelperBool(ON_RTreeNode const*, ON_RTreeNode const*, ON_RTreePairSearchCallbackResultBool*) | static bool SingleTreeSearchHelperBool(const ON_RTreeNode* a_nodeA, const ON_RTreeNode* a_nodeB, ON_RTreePairSearchCallbackResultBool* a_result)
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchA, *branchAmax, *branchB, *branchBmax;
branchA = a_nodeA->m_branch;
branchAmax = branchA + a_nod... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%r... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_RTree::BoundingBox() const | ON_BoundingBox ON_RTree::BoundingBox() const
{
ON_BoundingBox bbox;
if ( 0 != m_root && m_root->m_count > 0 )
{
bbox.m_min = m_root->m_branch[0].m_rect.m_min;
bbox.m_max = m_root->m_branch[0].m_rect.m_max;
for ( int i = 1; i < m_root->m_count; i++ )
{
if ( m_root->m_branch[i].m_rect.m_min[0]... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x32fb70
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x7320d4
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
j... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
NodeCover(ON_RTreeNode*) | static ON_RTreeBBox NodeCover(ON_RTreeNode* a_node)
{
int i;
const ON_RTreeBranch* branch;
ON_RTreeBBox rect;
if ( (i = a_node->m_count) > 0 )
{
rect = a_node->m_branch[--i].m_rect;
for ( branch = a_node->m_branch; i; i--, branch++ )
{
#if (3 == ON_RTree_NODE_DIM)
if ( rect.m_min[0] > branc... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x73273f
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
SearchBoundedPlaneXYZHelper(ON_RTreeNode const*, double const*, ON_RTreeSearchResultCallback&) | static
bool SearchBoundedPlaneXYZHelper(const ON_RTreeNode* a_node, const double* a_bounded_plane, ON_RTreeSearchResultCallback& a_result )
{
int i, count;
if ( (count = a_node->m_count) > 0 )
{
const ON_RTreeBranch* branch = a_node->m_branch;
if(a_node->IsInternalNode())
{
// a_node is an in... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jle 0x7333cb
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30df70
testb $0x1,... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
PairSearchHelper(ON_RTreeBranch const*, ON_RTreeNode const*, ON_RTreePairSearchResult*) | static void PairSearchHelper( const ON_RTreeBranch* a_branchA, const ON_RTreeNode* a_nodeB, ON_RTreePairSearchResult* a_result )
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchB, *branchBmax;
branchB = a_nodeB->m_branch;
branchBmax = branchB + a_nodeB->m_count;
while(branchB < branchBm... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rb... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
PairSearchHelper(ON_RTreeNode const*, ON_RTreeBranch const*, ON_RTreePairSearchCallbackResult*) | static void PairSearchHelper( const ON_RTreeNode* a_nodeA, const ON_RTreeBranch* a_branchB, ON_RTreePairSearchCallbackResult* a_result )
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchA, *branchAmax;
branchA = a_nodeA->m_branch;
branchAmax = branchA + a_nodeA->m_count;
while(branchA < ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp)... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
PairSearchHelper(ON_RTreeBranch const*, ON_RTreeNode const*, ON_RTreePairSearchCallbackResult*) | static void PairSearchHelper( const ON_RTreeBranch* a_branchA, const ON_RTreeNode* a_nodeB, ON_RTreePairSearchCallbackResult* a_result )
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchB, *branchBmax;
branchB = a_nodeB->m_branch;
branchBmax = branchB + a_nodeB->m_count;
while(branchB < ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rb... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
PairSearchHelperBoolTolerance(ON_RTreeNode const*, ON_RTreeBranch const*, ON_RTreePairSearchCallbackResultBoolTolerance*) | static bool PairSearchHelperBoolTolerance(const ON_RTreeNode* a_nodeA, const ON_RTreeBranch* a_branchB, ON_RTreePairSearchCallbackResultBoolTolerance* a_result)
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchA, *branchAmax;
branchA = a_nodeA->m_branch;
branchAmax = branchA + a_nodeA->m_c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%r... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
SingleTreeSearchHelper(ON_RTreeNode const*, ON_RTreeBranch const*, ON_RTreePairSearchCallbackResult*) | static void SingleTreeSearchHelper(const ON_RTreeNode* a_nodeA, const ON_RTreeBranch* a_branchB, ON_RTreePairSearchCallbackResult* a_result)
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchA, *branchAmax;
branchA = a_nodeA->m_branch;
branchAmax = branchA + a_nodeA->m_count;
if (a_nodeA... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp),... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
SingleTreeSearchHelperBool(ON_RTreeBranch const*, ON_RTreeNode const*, ON_RTreePairSearchCallbackResultBool*) | static bool SingleTreeSearchHelperBool(const ON_RTreeBranch* a_branchA, const ON_RTreeNode* a_nodeB, ON_RTreePairSearchCallbackResultBool* a_result)
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchB, *branchBmax;
branchB = a_nodeB->m_branch;
branchBmax = branchB + a_nodeB->m_count;
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%r... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
SingleTreeSearchHelperBoolTolerance(ON_RTreeBranch const*, ON_RTreeNode const*, ON_RTreePairSearchCallbackResultBoolTolerance*) | static bool SingleTreeSearchHelperBoolTolerance(const ON_RTreeBranch* a_branchA, const ON_RTreeNode* a_nodeB, ON_RTreePairSearchCallbackResultBoolTolerance* a_result)
{
// DO NOT ADD ANYTHING TO THIS FUNCTION
const ON_RTreeBranch *branchB, *branchBmax;
branchB = a_nodeB->m_branch;
branchBmax = branchB + a_node... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%r... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
CalcRectVolumeHelper(ON_RTreeBBox const*) | double CalcRectVolumeHelper(const ON_RTreeBBox* a_rect)
{
double d, r;
// Bounding sphere volume calculation is slower, but helps certain merge cases
#if ( 3 == ON_RTree_NODE_DIM)
// 3d bounding sphere volume
d = (a_rect->m_max[0] - a_rect->m_min[0]);
r = d * d;
d = (a_rect->m_max[1] - a_rect->m_min[1]);
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x8(%rax)... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
InitParVars(ON_RTreePartitionVars*, int, int) | static void InitParVars(ON_RTreePartitionVars* a_parVars, int a_maxRects, int a_minFill)
{
a_parVars->m_count[0] = a_parVars->m_count[1] = 0;
a_parVars->m_area[0] = a_parVars->m_area[1] = (double)0;
a_parVars->m_total = a_maxRects;
a_parVars->m_minFill = a_minFill;
for(int index=0; index < a_maxRects; ++index... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xb0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0xa8(%rax)
movl -0x... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
PickSeeds(ON_RTreePartitionVars*) | static void PickSeeds(ON_RTreePartitionVars* a_parVars)
{
int seed0 = 0, seed1 = 1;
double worst, waste;
double area[ON_RTree_MAX_NODE_COUNT+1];
for(int index=0; index<a_parVars->m_total; ++index)
{
area[index] = CalcRectVolumeHelper(&a_parVars->m_branchBuf[index].m_rect);
}
worst = -a_parVars->m_co... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x734800
movq -0x8(%rbp), %rdi
addq $0xb8, %rdi
movslq -0x64(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
ca... | /mcneel[P]opennurbs/opennurbs_rtree.cpp |
ON_SubDVertexIterator::NextVertex() | const class ON_SubDVertex* NextVertex()
{
m_vertex_index++;
if (m_vertex_index < m_vertex_count)
{
if (0 == m_component_ptr.m_ptr)
{
if (nullptr != m_v_current)
m_v_current = m_v_current->m_next_vertex;
}
else
{
const ON_SubDEdge* edge = m_component_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x28(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x28(%rcx)
movl 0x28(%rcx), %eax
cmpl 0x2c(%rcx), %eax
jae 0x735661
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq 0x30(%rcx), %rax
jne 0x7355e3
movq -0x20(%rbp), ... | /mcneel[P]opennurbs/opennurbs_subd.h |
ON_SubDVertexIterator::~ON_SubDVertexIterator() | class ON_CLASS ON_SubDVertexIterator
{
public:
// The best way to get an ON_SubDVertexIterator is so use the ON_SubD member function
// ON_SubDVertexIterator vit = subd.VertexIterator();
ON_SubDVertexIterator(
const class ON_SubD& subd
);
/// <summary>
/// An expert tool to iteratate over existing vert... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33b128
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_subd.h |
ON_SimpleArray<ON_RTreeLeaf>::SetCapacity(unsigned long) | T* ON_SimpleArray<T>::SetCapacity( size_t new_capacity )
{
if (0 == m_capacity)
{
// Allow "expert" users of ON_SimpleArray<>.SetArray(*,*,0) to clean up after themselves
// and deals with the case when the forget to clean up after themselves.
m_a = nullptr;
m_count = 0;
}
// sets capacity to ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jne 0x7358b2
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x7358cd
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<void*>::NewCapacity() const | int ON_SimpleArray<T>::NewCapacity() const
{
// Note:
// This code appears in ON_SimpleArray<T>::NewCapacity()
// and ON_ClassArray<T>::NewCapacity(). Changes made to
// either function should be made to both functions.
// Because this code is template code that has to
// support dynamic linking... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x10000000, -0x18(%rbp) # imm = 0x10000000
movslq 0x10(%rax), %rax
shlq $0x3, %rax
cmpq $0x10000000, %rax # imm = 0x10000000
jbe 0x735b02
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x735b2a
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SafeFrame::operator=(ON_SafeFrame const&) | const ON_SafeFrame& ON_SafeFrame::operator = (const ON_SafeFrame& sf)
{
if (this != &sf)
{
SetEnabled (sf.Enabled());
SetPerspectiveOnly (sf.PerspectiveOnly());
SetFieldGridOn (sf.FieldGridOn());
SetLiveFrameOn (sf.LiveFrameOn());
SetActionFrameOn (sf.ActionFrameOn());
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x736391
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x18(%rbp), %rdi
movb %al, %cl
movq (%rdi), %rax
movq 0x30(%rax), %rax
movzbl %cl, %es... | /mcneel[P]opennurbs/opennurbs_safe_frame.cpp |
ON_SectionStyle::IsValid(ON_TextLog*) const | bool ON_SectionStyle::IsValid( ON_TextLog* text_log ) const
{
if (false == ON_ModelComponent::IsValid(text_log))
return false;
// An ON_SectionStyle with an empty name is valid.
if (BoundaryWidthScale() <= 0)
{
if ( text_log )
text_log->Print("ON_SectionStyle::BoundaryWidthScale <= 0\n");
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x30b350
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7381a2
movb $0x0, -0x1(%rbp)
jmp 0x73820e
movq -0x20(%rbp), %rdi
callq 0x32d... | /mcneel[P]opennurbs/opennurbs_sectionstyle.cpp |
ON_SectionStyle::HatchColor(bool) const | ON_Color ON_SectionStyle::HatchColor(bool print) const
{
if (m_private)
return print ? m_private->m_hatch_print_color : m_private->m_hatch_color;
return ON_Color::UnsetColor;
} | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x90(%rax)
je 0x7388ab
testb $0x1, -0x11(%rbp)
je 0x73888d
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
addq $0x2c, %rax
movq %rax, -0x28(%rbp)
jmp 0x7388a0
movq... | /mcneel[P]opennurbs/opennurbs_sectionstyle.cpp |
ON_SectionStyle::SetBackgroundFillColor(ON_Color const&, bool) | void ON_SectionStyle::SetBackgroundFillColor(const ON_Color& color, bool print)
{
if (BackgroundFillColor(print) == color)
return;
if (nullptr == m_private)
m_private = new ON_SectionStylePrivate();
if (print)
m_private->m_background_fill_print_color = color;
else
m_private->m_background_fill_c... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x317cf0
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3151d0
movl ... | /mcneel[P]opennurbs/opennurbs_sectionstyle.cpp |
ON_SectionStyle::SetBoundaryColor(ON_Color const&, bool) | void ON_SectionStyle::SetBoundaryColor(const ON_Color& color, bool print)
{
if (BoundaryColor(print) == color)
return;
if (nullptr == m_private)
m_private = new ON_SectionStylePrivate();
if (print)
m_private->m_boundary_print_color = color;
else
m_private->m_boundary_color = color;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2ff370
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3151d0
movl ... | /mcneel[P]opennurbs/opennurbs_sectionstyle.cpp |
ON_SectionStyle::SetHatchColor(ON_Color const&, bool) | void ON_SectionStyle::SetHatchColor(const ON_Color& color, bool print)
{
if (HatchColor(print) == color)
return;
if (nullptr == m_private)
m_private = new ON_SectionStylePrivate();
if (print)
m_private->m_hatch_print_color = color;
else
m_private->m_hatch_color = color;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3208e0
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3151d0
movl ... | /mcneel[P]opennurbs/opennurbs_sectionstyle.cpp |
ON_SHA1_Hash::Read(ON_BinaryArchive&) | bool ON_SHA1_Hash::Read(
class ON_BinaryArchive& archive
)
{
*this = ON_SHA1_Hash::ZeroDigest;
bool rc = false;
int major_version = 0;
int minor_version = 0;
if (!archive.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version))
return rc;
for (;;)
{
if ( 1 != major_version )
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x3431b9(%rip), %rcx # 0xa7d7d8
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movb $0x0, -0x19(%rbp)... | /mcneel[P]opennurbs/opennurbs_sha1.cpp |
ON_SHA1_Hash::Dump(ON_TextLog&) const | void ON_SHA1_Hash::Dump(
class ON_TextLog& text_log
) const
{
ON_wString sha1_hash;
if ( ON_SHA1_Hash::ZeroDigest == *this )
sha1_hash = L"ZeroDigest";
else if ( ON_SHA1_Hash::EmptyContentHash == *this )
sha1_hash = L"EmptyContentHash";
else
sha1_hash = ToString(true);
text_log.Print(L"ON_SHA1_... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3390e0
movq -0x38(%rbp), %rsi
movq 0x34306c(%rip), %rdi # 0xa7d7d8
callq 0x3116d0
testb $0x1, %al
jne 0x73a777
jmp 0x73a79f
leaq 0x1cdc3a(%rip), %rsi ... | /mcneel[P]opennurbs/opennurbs_sha1.cpp |
ON_SHA1_Hash::StringHash(ON_wString const&, unsigned long&) | ON_SHA1_Hash ON_SHA1_Hash::StringHash(
const ON_wString& str,
ON__UINT64& byte_count
)
{
// Do not permit corrupt strings to crash this code.
str.IsValid(false);
return ON_SHA1_Hash::StringHash(
static_cast<const wchar_t*>(str),
(size_t)str.Length(),
byte_count
);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x335b30
movq -0x8(%rbp), %rdi
callq 0x319c90
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3082f0
movq -0x28(%rbp), %rdi
movq -0x20(%... | /mcneel[P]opennurbs/opennurbs_sha1.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.