name string | code string | asm string | file string |
|---|---|---|---|
ON_PlaneSurface::CreateMesh(ON_Mesh*) const | ON_Mesh* ON_PlaneSurface::CreateMesh(
ON_Mesh* mesh
) const
{
ON_Mesh* rc = nullptr;
if (m_plane.IsValid() && m_domain[0].IsValid() && m_domain[1].IsValid())
{
bool vn = false, fn = false, sp = true;
if (mesh == nullptr) mesh = new ON_Mesh();
else
{
if (!mesh->HasDoublePrecisionVertices(... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x10, %rdi
callq 0x32e8e0
testb $0x1, %al
jne 0x6c9388
jmp 0x6c99f2
movq -0x128(%rbp), %rdi
addq $0x90, %rdi
callq 0x314580
testb ... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_ClippingPlaneInfo::Read(ON_BinaryArchive&) | bool ON_ClippingPlaneInfo::Read( ON_BinaryArchive& file )
{
Default();
int major_version = 0;
int minor_version = 0;
bool rc = file.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version);
if (!rc)
return false;
for(;;)
{
rc = (1 == major_version);
if (!rc) break;
rc = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3199f0
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x40008000, %esi # imm = 0x40008000
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq ... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_ClippingPlaneData::HasDefaultContent() const | bool ON_ClippingPlaneData::HasDefaultContent() const
{
if (m_depth != 0.0)
return false;
if (m_object_id_list.Count()>0)
return false;
if (m_layer_list.Count() > 0)
return false;
if (!m_is_exclusion_list)
return false;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6c9dc6
jp 0x6c9dc6
jmp 0x6c9dcc
movb $0x0, -0x1(%rbp)
jmp 0x6c9e10
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x327c80
cmpl $0x0, %eax
... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_ClippingPlaneDataList::DeleteEntry(unsigned int) | void ON_ClippingPlaneDataList::DeleteEntry(unsigned int sn)
{
int count = m_list.Count();
for (int i=0; i<count; i++)
{
ON_ClippingPlaneData* data = m_list[i];
if (data && data->m_sn == sn)
{
delete data;
m_list.Remove(i);
return;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x2fd090
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6c9f83
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x301cc0
movq (... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_ClippingPlaneDataStore::ON_ClippingPlaneDataStore(ON_ClippingPlaneDataStore const&) | ON_ClippingPlaneDataStore::ON_ClippingPlaneDataStore(const ON_ClippingPlaneDataStore& src)
{
ON_ClippingPlaneData* srcData = GetClippingPlaneData(src.m_sn);
if (srcData)
{
ON_ClippingPlaneData* thisData = GetClippingPlaneData(*this, true);
if (thisData)
{
thisData->m_depth = srcData->m_depth;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x6ca1a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ca18d
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x6ca210
... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
GetClippingPlaneData(unsigned int) | static ON_ClippingPlaneData* GetClippingPlaneData(unsigned int sn)
{
if (0==sn)
return nullptr;
bool bReturnLock = g_data_list_lock.GetLock();
ON_ClippingPlaneData* rc = g_data_list.FromSerialNumber(sn);
if(bReturnLock)
g_data_list_lock.ReturnLock();
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jne 0x6ca1bc
movq $0x0, -0x8(%rbp)
jmp 0x6ca1fa
leaq 0x3e247d(%rip), %rdi # 0xaac640
callq 0x31c830
andb $0x1, %al
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %esi
leaq 0x3e2451(%rip), %rdi # 0xaac628
callq 0x32c710
... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_ClippingPlaneSurface::Write(ON_BinaryArchive&) const | bool ON_ClippingPlaneSurface::Write( ON_BinaryArchive& file ) const
{
bool rc = file.BeginWrite3dmChunk(TCODE_ANONYMOUS_CHUNK,1,0);
if (!rc)
return false;
for(;;)
{
rc = file.BeginWrite3dmChunk(TCODE_ANONYMOUS_CHUNK,0);
if (rc)
{
rc = ON_PlaneSurface::Write(file)?true:false;
if (!fi... | 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), %rdi
movl $0x40008000, %esi # imm = 0x40008000
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x305e30
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_ClippingPlaneSurface::operator=(ON_ClippingPlaneSurface const&) | class ON_CLASS ON_ClippingPlaneSurface : public ON_PlaneSurface
{
ON_OBJECT_DECLARE(ON_ClippingPlaneSurface);
public:
ON_ClippingPlaneSurface();
ON_ClippingPlaneSurface(const ON_Plane& src);
ON_ClippingPlaneSurface(const ON_PlaneSurface& src);
~ON_ClippingPlaneSurface();
ON_ClippingPlaneSurface& operator=(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x336060
movq -0x18(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
addq $0xd0, %rsi
callq 0x30d0e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
ret... | /mcneel[P]opennurbs/opennurbs_planesurface.h |
ON_ClippingPlaneSurface::ON_ClippingPlaneSurface(ON_ClippingPlaneSurface const&) | class ON_CLASS ON_ClippingPlaneSurface : public ON_PlaneSurface
{
ON_OBJECT_DECLARE(ON_ClippingPlaneSurface);
public:
ON_ClippingPlaneSurface();
ON_ClippingPlaneSurface(const ON_Plane& src);
ON_ClippingPlaneSurface(const ON_PlaneSurface& src);
~ON_ClippingPlaneSurface();
ON_ClippingPlaneSurface& operator=(... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3353d0
movq -0x28(%rbp), %rdi
movq 0x3b296c(%rip), %rax # 0xa7e708
addq $0x10, %rax
movq %rax, (%rdi)
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
addq $0xd0... | /mcneel[P]opennurbs/opennurbs_planesurface.h |
ON_ClippingPlaneData::ON_ClippingPlaneData() | ON_ClippingPlaneData():m_object_id_list(0){} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x10, %rdi
xorl %esi, %esi
callq 0x2fa660
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x306d20
movq -0x10(%rbp), %rax
movb $0x1, 0x48(%rax)
m... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_SimpleArray<ON_ClippingPlaneData*>::Append(ON_ClippingPlaneData* 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 0x6cc044
movq -0x30(%rbp), %rdi
callq 0x2fc1c0
movq -0x30(%rbp), %rcx
movl %eax, -0x1c(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_ClippingPlaneInfo::ON_ClippingPlaneInfo() | class ON_CLASS ON_ClippingPlaneInfo
{
public:
// C++ defaults for construction, destruction, copy construction
// and operator= work fine.
// A point is visible if m_plane_equation.ValueAt(point) <= 0.
// (This is the opposite convention from what OpenGL uses.)
ON_PlaneEquation m_plane_equation;
ON_UUID m_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3297f0
movq -0x20(%rbp), %rax
movq 0x3b080c(%rip), %rcx # 0xa7c8b0
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rax)
movb $0x0, 0x30(%rax)
movb $0x0, 0x31(%rax)
addq... | /mcneel[P]opennurbs/opennurbs_plane.h |
ON_CompareDoubleArray(unsigned long, double const*, double const*) | int ON_CompareDoubleArray(
size_t count,
const double* a,
const double* b
)
{
if (count <= 0)
return 0;
if (a == b)
return 0;
if (nullptr == a)
return 1;
if (nullptr == b)
return -1;
return Internal_DoubleArrayCompare(count, a, b);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
ja 0x6cd334
movl $0x0, -0x4(%rbp)
jmp 0x6cd37d
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x6cd347
movl $0x0, -0x4(%rbp)
jmp 0x6cd37d
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne ... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4dPoint::ProjectiveCompare(ON_4dPoint const&, ON_4dPoint const&) | int ON_4dPoint::ProjectiveCompare(
const ON_4dPoint& lhs,
const ON_4dPoint& rhs
)
{
if (lhs.w == rhs.w)
{
// neither lhs.w nor rhs.w is a nan
return Internal_DoubleArrayCompare(3, &lhs.x, &rhs.x);
}
if (0.0 != lhs.w && 0.0 != rhs.w)
{
// neither lhs.w nor rhs.w is a nan
return ON_3dPoin... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jne 0x6cdfa0
jp 0x6cdfa0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x3, %edi
callq 0x6cd390
movl %eax, -0x4(%rbp)
jmp 0x6ce0... | /mcneel[P]opennurbs/opennurbs_point.cpp |
Internal_FloatArrayCompare(unsigned long, float const*, float const*) | static int Internal_FloatArrayCompare(
size_t count,
const float* a,
const float* b
)
{
const float* e = a + count;
int rc = ON_CompareFloat(*a++, *b++);
while( 0 == rc && a < e)
rc = ON_CompareFloat(*a++, *b++);
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rbp)
movss (%rax), %xmm0
movq -0x18... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_Interval::ClampedParameterAt(double) const | double ON_Interval::ClampedParameterAt(
double x
) const
{
if (ON_IS_VALID(x) && ON_IS_VALID(m_t[0]) && ON_IS_VALID(m_t[1]))
{
if (x <= 0.0)
return m_t[0];
if (x >= 1.0)
return m_t[1];
if (m_t[0] == m_t[1])
return m_t[0]; // no fuzz from a linear combination
return ((1.0 - x) * ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x204e26(%rip), %xmm1 # 0x8d3768
ucomisd %xmm1, %xmm0
jbe 0x6cea4e
movsd 0x20fc74(%rip), %xmm0 # 0x8de5c8
ucomisd -0x18(%rbp), %xmm0
jbe 0x6cea4e
movq -0x20(%rbp), ... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_Interval::ClampedNormalizedParameterAt(double) const | double ON_Interval::ClampedNormalizedParameterAt(
double interval_parameter
) const
{
if (ON_IS_VALID(interval_parameter) && ON_IS_VALID(m_t[0]) && ON_IS_VALID(m_t[1]))
{
if (m_t[0] < m_t[1])
{
// this is an increasing interval
if (interval_parameter <= m_t[0])
return 0.0;
if (in... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x204cd6(%rip), %xmm1 # 0x8d3768
ucomisd %xmm1, %xmm0
jbe 0x6cec2c
movsd 0x20fb24(%rip), %xmm0 # 0x8de5c8
ucomisd -0x18(%rbp), %xmm0
jbe 0x6cec2c
movq -0x20(%rbp), ... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_Interval::Length() const | double
ON_Interval::Length() const
{
return ( ON_IS_VALID(m_t[0]) && ON_IS_VALID(m_t[1]) ) ? m_t[1]-m_t[0] : 0.0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd (%rax), %xmm0
movsd 0x20468c(%rip), %xmm1 # 0x8d3768
ucomisd %xmm1, %xmm0
jbe 0x6cf132
movq -0x10(%rbp), %rax
movsd 0x20f4da(%rip), %xmm0 # 0x8de5c8
ucomisd (%rax), %xmm0
jbe 0x6cf132
movq -0x10(%rbp), %rax
movsd 0x8... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_Interval::Union(int, double const*) | bool ON_Interval::Union(
int count,
const double* t
)
{
bool rc = false;
double a, mn, mx;
if ( 0 != t )
{
while ( count > 0 && !ON_IsValid(*t) )
{
count--;
t++;
}
}
if ( count <= 0 || 0 == t )
{
// this may be increasing, decreasing, or empty
if ( !IsEmptyInterval(... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x6cfc38
jmp 0x6cfbf9
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x41(%rbp)
jle 0x6cfc16
movq... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::Decompose(ON_3dVector const&, ON_3dVector const&, ON_3dVector const&, double*, double*, double*) const | bool ON_3dVector::Decompose( // Computes a, b, c such that this vector = a*X + b*Y + c*Z
//
// If X,Y,Z is known to be an orthonormal frame,
// then a = V*X, b = V*Y, c = V*Z will compute
// the same result more quickly.
const ON_3dVector& X,
const ON_3dVector& Y,
const ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
callq 0x3257... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::IsPerpendicularTo(ON_3dVector const&, double) const | bool ON_3dVector::IsPerpendicularTo(
// returns true: this and other vectors are perpendicular
// false: this and other vectors are not perpendicular
// or at least one of the vectors is zero
const ON_3dVector& v,
double angle_tolerance // (default=ON_DEFAULT_ANGLE_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x306790
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x306790
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %x... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_2fPoint::Transform(ON_Xform const&) | void ON_2fPoint::Transform( const ON_Xform& xform )
{
double xx,yy,ww;
ww = xform.m_xform[3][0]*x + xform.m_xform[3][1]*y + xform.m_xform[3][3];
if ( ww != 0.0 )
ww = 1.0/ww;
xx = ww*(xform.m_xform[0][0]*x + xform.m_xform[0][1]*y + xform.m_xform[0][3]);
yy = ww*(xform.m_xform[1][0]*x + xform.m_xform[1][1]... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movsd 0x60(%rcx), %xmm0
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movq -0x10(%rbp), %rcx
movsd 0x68(%rcx), %xmm1
movss 0x4(%rax), %xmm3
cvtss2sd %xmm3, %xmm3
mulsd %xmm3, %xmm1
mul... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3fPoint::Transform(ON_Xform const&) | void ON_3fPoint::Transform( const ON_Xform& xform )
{
const double ww = xform.m_xform[3][0]*x + xform.m_xform[3][1]*y + xform.m_xform[3][2]*z + xform.m_xform[3][3];
if (0.0 == ww)
{
ON_ERROR("divide by zero.");
*this = ON_3fPoint::NanPoint;
}
else
{
const double xx = (xform.m_xform[0][0] * x + x... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movsd 0x60(%rcx), %xmm1
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm2
movq -0x10(%rbp), %rcx
movsd 0x68(%rcx), %xmm0
movss 0x4(%rax), %xmm3
cvtss2sd %xmm3, %xmm3
mulsd... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::Transform(ON_Xform const&) | void ON_3dVector::Transform( const ON_Xform& xform )
{
double xx,yy,zz;
xx = xform.m_xform[0][0]*x + xform.m_xform[0][1]*y + xform.m_xform[0][2]*z;
yy = xform.m_xform[1][0]*x + xform.m_xform[1][1]*y + xform.m_xform[1][2]*z;
zz = xform.m_xform[2][0]*x + xform.m_xform[2][1]*y + xform.m_xform[2][2]*z;
x = xx;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm1
movsd (%rax), %xmm2
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd 0x1... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_IsOrthonormalFrame(ON_2dVector const&, ON_2dVector const&) | bool ON_IsOrthonormalFrame( const ON_2dVector& X, const ON_2dVector& Y )
{
// returns true if X, Y, Z is an orthonormal frame
if ( !ON_IsOrthogonalFrame( X, Y ) )
return false;
double x = X.Length();
if ( fabs(x-1.0) > ON_SQRT_EPSILON )
return false;
x = Y.Length();
if ( fabs(x-1.0) > ON_SQRT_EPS... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x31a630
testb $0x1, %al
jne 0x6d301a
movb $0x0, -0x1(%rbp)
jmp 0x6d309a
movq -0x10(%rbp), %rdi
callq 0x31a5f0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x1fffcb(%r... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_IsOrthogonalFrame(ON_3dVector const&, ON_3dVector const&, ON_3dVector const&) | bool ON_IsOrthogonalFrame( const ON_3dVector& X, const ON_3dVector& Y, const ON_3dVector& Z )
{
// returns true if X, Y, Z is an orthogonal frame
if (! X.IsValid() || !Y.IsValid() || !Z.IsValid() )
return false;
double lx = X.Length();
double ly = Y.Length();
double lz = Z.Length();
if ( lx <= ON_SQ... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a800
testb $0x1, %al
jne 0x6d3486
jmp 0x6d34a2
movq -0x18(%rbp), %rdi
callq 0x31a800
testb $0x1, %al
jne 0x6d3495
jmp 0x6d34a2
movq -0x20(%rbp), %rd... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_2dPoint::operator*(ON_Xform const&) const | ON_2dPoint ON_2dPoint::operator*( const ON_Xform& xform ) const
{
const double px = x; // optimizer should put px,py in registers
const double py = y;
double hx[2], w;
const double* m = &xform.m_xform[0][0];
hx[0] = m[0]*px + m[4]*py + m[12];
hx[1] = m[1]*px + m[5]*py + m[13];
w = m[3]*px + m[7]*py + ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movsd (%rax), %xmm0
movsd -0x28(%rbp), %xmm2
... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::operator*(ON_Xform const&) const | ON_3dVector ON_3dVector::operator*( const ON_Xform& xform ) const
{
const double vx = x; // optimizer should put vx,vy,vz in registers
const double vy = y;
const double vz = z;
double hx[3];
const double* m = &xform.m_xform[0][0];
hx[0] = m[0]*vx + m[4]*vy + m[ 8]*vz;
hx[1] = m[1]*vx + m[5]*vy + m[ 9]*vz;... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq ... | /mcneel[P]opennurbs/opennurbs_point.cpp |
Internal_NotEqualFloatArray(unsigned long, float const*, float const*) | static bool Internal_NotEqualFloatArray(size_t count, const float* lhs, const float* rhs)
{
bool rc = false;
const float* e = lhs + count;
while (lhs < e)
{
const float x = *lhs++;
const float y = *rhs++;
if (x != y)
{
// neither x nor y is a nan
rc = true;
continue;
}
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x6d57a2
movq -0x18(%rbp), %rax
movq %rax, %rcx
ad... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3fPoint::operator=(float const*) | ON_3fPoint& ON_3fPoint::operator=(const float* p)
{
if ( p ) {
x = p[0];
y = p[1];
z = p[2];
}
else {
x = y = z = 0.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6d6589
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%r... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3fPoint::operator>(ON_3fPoint const&) const | bool ON_3fPoint::operator>( const ON_3fPoint& p ) const
{
// dictionary order
return ((x>p.x)?true:((x==p.x)?((y>p.y)?true:(y==p.y&&z>p.z)?true:false):false));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomiss (%rax), %xmm0
jbe 0x6d76a8
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x6d7725
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomiss (... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3fPoint::operator[](unsigned int) | float& ON_3fPoint::operator[](unsigned int i)
{
float* pd = (i<=0)? &x : ( (i>=2) ? &z : &y);
return *pd;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
ja 0x6d7873
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x6d789b
cmpl $0x2, -0xc(%rbp)
jb 0x6d7887
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x6d7893
mo... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3fPoint::IsNotZero() const | bool ON_3fPoint::IsNotZero() const
{
// the && (x != ON_UNSET_FLOAT && y != ON_UNSET_FLOAT && z != ON_UNSET_FLOAT) insures no coordinate is a Nan.
return
(x != 0.0f || y != 0.0f || z != 0.0f)
&& (x != ON_UNSET_FLOAT && y != ON_UNSET_FLOAT && z != ON_UNSET_FLOAT)
&& (x != ON_UNSET_POSITIVE_FLOAT && y != ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6d7cee
jp 0x6d7cee
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6d7cee
jp 0x6d7cee
movq -0x10(%rbp), %rax
movss 0... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4fPoint::operator=(float const*) | ON_4fPoint& ON_4fPoint::operator=(const float* p)
{
if ( p ) {
x = p[0];
y = p[1];
z = p[2];
w = p[3];
}
else {
x = y = z = 0.0; w = 1.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6d8477
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%r... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4fPoint::operator+=(ON_4fPoint const&) | ON_4fPoint& ON_4fPoint::operator+=(const ON_4fPoint& p)
{
// sum w = sqrt(w1*w2)
if ( p.w == w ) {
x += p.x;
y += p.y;
z += p.z;
}
else if (p.w == 0.0 ) {
x += p.x;
y += p.y;
z += p.z;
}
else if ( w == 0.0 ) {
x += p.x;
y += p.y;
z += p.z;
w = p.w;
}
else {
co... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movss 0xc(%rcx), %xmm0
ucomiss 0xc(%rax), %xmm0
jne 0x6d88a8
jp 0x6d88a8
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
addss (%rax), %xmm0
movs... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4fPoint::operator[](unsigned int) const | float ON_4fPoint::operator[](unsigned int i) const
{
return ((i<=0)?x:((i>=3)?w:((i==1)?y:z)));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
ja 0x6d90f8
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x6d9146
cmpl $0x3, -0xc(%rbp)
jb 0x6d910e
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xm... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_2fVector::operator=(double const*) | ON_2fVector& ON_2fVector::operator=(const double* v)
{
if ( v ) {
x = (float)v[0];
y = (float)v[1];
}
else {
x = y = 0.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6d97b3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
cvtsd2ss %xmm0... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_2fVector::Unitize() | bool ON_2fVector::Unitize()
{
bool rc = false;
// Since x,y are floats, d will not be denormalized and the
// ON_DBL_MIN tests in ON_2dVector::Unitize() are not needed.
double d = Length();
if ( d > 0.0 )
{
double dx = (double)x;
double dy = (double)y;
x = (float)(dx/d);
y = (float)(dy/d);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x30da90
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6da8d8
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movs... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3fVector::operator=(float const*) | ON_3fVector& ON_3fVector::operator=(const float* v)
{
if ( v ) {
x = v[0];
y = v[1];
z = v[2];
}
else {
x = y = z = 0.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6db499
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
movss %xmm0, 0x4(%rax)
movq -0x10(%r... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_2dPoint::operator=(float const*) | ON_2dPoint& ON_2dPoint::operator=(const float* p)
{
if ( p ) {
x = (double)p[0];
y = (double)p[1];
}
else {
x = y = 0.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6dd4e3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
cvtss2sd %xmm0... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dPoint::ON_3dPoint(ON_4dPoint const&) | ON_3dPoint::ON_3dPoint(const ON_4dPoint& p)
{
x=p.x;y=p.y;z=p.z;
const double w = (p.w != 1.0 && p.w != 0.0) ? 1.0/p.w : 1.0;
x *= w;
y *= w;
z *= w;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dPoint::operator>=(ON_3dPoint const&) const | bool ON_3dPoint::operator>=( const ON_3dPoint& p ) const
{
// dictionary order
return ((x>p.x)?true:((x==p.x)?((y>p.y)?true:(y==p.y&&z>=p.z)?true:false):false));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x6dfefc
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x6dff7d
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dPoint::operator>(ON_3dPoint const&) const | bool ON_3dPoint::operator>( const ON_3dPoint& p ) const
{
// dictionary order
return ((x>p.x)?true:((x==p.x)?((y>p.y)?true:(y==p.y&&z>p.z)?true:false):false));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x6e007c
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x6e00fd
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dPoint::operator[](unsigned int) | double& ON_3dPoint::operator[](unsigned int i)
{
double* pd = (i<=0)? &x : ( (i>=2) ? &z : &y);
return *pd;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
ja 0x6e0253
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x6e027b
cmpl $0x2, -0xc(%rbp)
jb 0x6e0267
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x6e0273
m... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4dPoint::operator=(float const*) | ON_4dPoint& ON_4dPoint::operator=(const float* p)
{
if ( p ) {
x = (double)p[0];
y = (double)p[1];
z = (double)p[2];
w = (double)p[3];
}
else {
x = y = z = 0.0; w = 1.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6e0eb7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
cvtss2sd %xmm0... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4dPoint::operator/=(double) | ON_4dPoint& ON_4dPoint::operator/=(double d)
{
const double one_over_d = 1.0/d;
x *= one_over_d;
y *= one_over_d;
z *= one_over_d;
w *= one_over_d;
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x1f1d37(%rip), %xmm0 # 0x8d3000
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
mulsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%ra... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4dPoint::operator[](int) | double& ON_4dPoint::operator[](int i)
{
double* pd = (i<=0) ? &x : ( (i>=3) ? &w : (i==1)?&y:&z);
return *pd;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x6e1af3
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x6e1b37
cmpl $0x3, -0xc(%rbp)
jl 0x6e1b07
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x6e1b2f
c... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_4dPoint::operator[](unsigned int) | double& ON_4dPoint::operator[](unsigned int i)
{
double* pd = (i<=0) ? &x : ( (i>=3) ? &w : (i==1)?&y:&z);
return *pd;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
ja 0x6e1bf3
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x6e1c37
cmpl $0x3, -0xc(%rbp)
jb 0x6e1c07
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
jmp 0x6e1c2f
c... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_2dVector::operator=(float const*) | ON_2dVector& ON_2dVector::operator=(const float* v)
{
if ( v ) {
x = (double)v[0];
y = (double)v[1];
}
else {
x = y = 0.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6e2343
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movss 0x4(%rcx), %xmm0
cvtss2sd %xmm0... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_2dVector::Unitize() | bool ON_2dVector::Unitize()
{
// 15 September 2003 Dale Lear
// Added the ON_IS_FINITE and ON_DBL_MIN test. See ON_2dVector::Length()
// for details.
double d = Length();
if ( ON_IS_FINITE(d) )
{
if ( d > ON_DBL_MIN )
{
x /= d;
y /= d;
return true;
}
if ( d >... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x31a5f0
movsd %xmm0, -0x18(%rbp)
movzwl -0x12(%rbp), %ecx
andl $0x7ff0, %ecx # imm = 0x7FF0
movl $0x7ff0, %eax # imm = 0x7FF0
cmpl %ecx, %eax
je 0x6e35d1
movsd -0x18(%rbp), %xmm0
m... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::UnitVector(int) | const ON_3dVector& ON_3dVector::UnitVector(int index)
{
static ON_3dVector o(0.0,0.0,0.0);
static ON_3dVector x(1.0,0.0,0.0);
static ON_3dVector y(0.0,1.0,0.0);
static ON_3dVector z(0.0,0.0,1.0);
switch(index)
{
case 0:
return x;
case 1:
return y;
case 2:
return z;
}
return o;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpb $0x0, 0x3c8c16(%rip) # 0xaac738
jne 0x6e3b58
leaq 0x3c8c0d(%rip), %rdi # 0xaac738
callq 0x30a330
cmpl $0x0, %eax
je 0x6e3b58
leaq 0x3c8be4(%rip), %rdi # 0xaac720
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x326540
jmp ... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::operator=(double const*) | ON_3dVector& ON_3dVector::operator=(const double* v)
{
if ( v ) {
x = v[0];
y = v[1];
z = v[2];
}
else {
x = y = z = 0.0;
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6e40f9
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%r... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::operator>=(ON_3dVector const&) const | bool ON_3dVector::operator>=( const ON_3dVector& v ) const
{
// dictionary order
return ((x>v.x)?true:((x==v.x)?((y>v.y)?true:(y==v.y&&z>=v.z)?true:false):false));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x6e4f0c
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x6e4f8d
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dVector::operator>(ON_3dVector const&) const | bool ON_3dVector::operator>( const ON_3dVector& v ) const
{
// dictionary order
return ((x>v.x)?true:((x==v.x)?((y>v.y)?true:(y==v.y&&z>v.z)?true:false):false));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x6e508c
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x6e510d
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_PlaneEquation::ValueAt(int, ON_3dPoint const*, double*, double*) const | double* ON_PlaneEquation::ValueAt(
int Pcount,
const ON_3dPoint* P,
double* value,
double value_range[2]
) const
{
if ( Pcount <= 0 || 0 == P )
return 0;
int i;
double s;
const double* e = &x;
if ( 0 == value )
value = (double*)onmalloc(Pcount * sizeof(*value) );
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x6e83d1
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x6e83de
movq $0x0, -0x8(%rbp)
jmp 0x... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dPointListRef::SetFromDoubleArray(unsigned long, unsigned long, double const*) | unsigned int ON_3dPointListRef::SetFromDoubleArray(
size_t point_count,
size_t point_stride,
const double* point_array
)
{
*this = ON_3dPointListRef::EmptyPointList;
if ( point_count > 0
&& point_count < (size_t)ON_UNSET_UINT_INDEX
&& point_stride >= 3
&& point_stride < (size_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x39447d(%rip), %rcx # 0xa7cb40
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_PlaneEquation::MinimumValueAt(ON_BoundingBox const&) const | double ON_PlaneEquation::MinimumValueAt(const ON_BoundingBox& bbox) const
{
double xx, yy, zz, s;
s = x*bbox.m_min.x;
if ( s < (xx = x*bbox.m_max.x) ) xx = s;
s = y*bbox.m_min.y;
if ( s < (yy = y*bbox.m_max.y) ) yy = s;
s = z*bbox.m_min.z;
if ( s < (zz = z*bbox.m_max.z) ) zz = s;
return (xx + yy + z... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd (%rax), %xmm0
movq -0x10(%rbp), %rcx
mulsd (%rcx), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x18(%rax), %xmm0
movsd %xmm0, -0x18(%rbp... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_PlaneEquation::MinimumValueAt(bool, int, int, double const*, double) const | double ON_PlaneEquation::MinimumValueAt(
bool bRational,
int point_count,
int point_stride,
const double* points,
double stop_value
) const
{
double value, min_value, w;
if ( point_count < 1
|| point_stride < (bRational?4:3)
|| 0 == points
)
{
return ON_UNSET_VALUE;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x1, -0x18(%rbp)
jl 0x6e9d05
movl -0x1c(%rbp), %eax
movb... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_3dPointListRef::GetPoints(int, int const*, ON_SimpleArray<ON_3dPoint>&) const | unsigned int ON_3dPointListRef::GetPoints(
int point_index_count,
const int* point_index_list,
ON_SimpleArray<ON_3dPoint>& points
) const
{
unsigned int rc = (point_index_count > 0)
? GetPoints((unsigned int)point_index_count,(const unsigned int*)point_index_list,points)
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x6ef59e
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2fee90
... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_WindingNumber::AddBoundary(unsigned long, unsigned long, int const*, bool) | ON__UINT32 ON_WindingNumber::AddBoundary(size_t point_count, size_t point_stride, const int* boundary_points, bool bCloseBoundary)
{
const ON__UINT32 boundary_segment_count0 = m_boundary_segment_count;
if (Internal_HaveWindingPoint() && point_count >= 2 && point_stride >= 2 && nullptr != boundary_points)
{
ON... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl 0x20(%rdi), %eax
movl %eax, -0x28(%rbp)
callq 0x3306f0
testb $0x1, %al
jne 0x6f117c... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_PeriodicDomain::LiftToCover(ON_2dPoint, bool) | ON_2dPoint ON_PeriodicDomain::LiftToCover(ON_2dPoint Pin, bool stealth )
{
ON_2dPoint out = Pin;
ON_2dPoint nnext;
int deck_in[2] = { 0,0 };
// decompose Pin
// Pin = m_dom.ParameterAt( deck + nnext)
// where nnext[i] is in [0.0, 1.0)
for (int i = 0; i < 2; i++)
{
nnext[i] = m_dom[i].NormalizedParameterA... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x58(%r... | /mcneel[P]opennurbs/opennurbs_point.cpp |
ON_PointCloud::operator=(ON_PointCloud const&) | ON_PointCloud& ON_PointCloud::operator=( const ON_PointCloud& src )
{
if ( this != &src ) {
Destroy();
ON_Geometry::operator=(src);
m_P = src.m_P;
m_H = src.m_H;
m_C = src.m_C;
m_V = src.m_V;
m_N = src.m_N;
m_hidden_count = src.m_hidden_count;
m_plane = src.m_plane;
m_bbox = s... | 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 0x6f2045
movq -0x18(%rbp), %rdi
callq 0x32cd40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x313510
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_PointCloud::Destroy() | void ON_PointCloud::Destroy()
{
m_H.Destroy();
m_C.Destroy();
m_V.Destroy();
m_N.Destroy();
m_P.Destroy();
m_hidden_count=0;
m_flags = 0;
m_bbox.Destroy();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x70, %rdi
callq 0x337e40
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x309670
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x318360
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x307e70
movq -0x10(%... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_PointCloud::ON_PointCloud(double const*, int, bool, int) | ON_PointCloud::ON_PointCloud(const double* P0, int dim, bool is_rat, int count) : m_P(count)
{
m_P.Create(dim, is_rat, count, dim + is_rat, P0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x336a30
movq -0x40(%rbp), %rdi
movq 0x38b092(%rip), %rax # 0xa7d848
addq $0x10,... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_PointCloud::Read(ON_BinaryArchive&) | bool ON_PointCloud::Read( ON_BinaryArchive& file )
{
int major_version = 0;
int minor_version = 0;
bool rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc && major_version == 1 )
{
if (rc) rc = file.ReadArray( m_P );
if (rc) rc = file.ReadPlane( m_plane );
if (rc) rc = file.Read... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x328980
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_PointCloud::GetBBox(double*, double*, bool) const | bool ON_PointCloud::GetBBox( // returns true if successful
double* boxmin, // minimum
double* boxmax, // maximum
bool bGrowBox // true means grow box
) const
{
if ( !m_bbox.IsValid() ) {
m_P.GetBBox( (double*)&m_bbox.m_min.x, (double*)&m_bbox.m_max.x, false );
}
bool rc = m_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
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, -0x28(%rbp)
addq $0x110, %rdi # imm = 0x110
callq 0x3137a0
testb $0x1, %al
jne 0x6f30ba
movq -0x28(%rbp), %rdx
mo... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_PointCloud::SwapCoordinates(int, int) | bool ON_PointCloud::SwapCoordinates(
int i, int j // indices of coords to swap
)
{
bool rc = m_P.SwapCoordinates(i,j);
if ( rc && HasPlane() ) {
rc = m_plane.SwapCoordinates(i,j);
}
if ( rc && m_bbox.IsValid() ) {
rc = m_bbox.SwapCoordinates(i,j);
}
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x303f60
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x6f33be
movq -0x20(%rb... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_3dPointArray::GetClosestPoint(ON_3dPoint, int*, double) const | bool ON_3dPointArray::GetClosestPoint(
ON_3dPoint P,
int* closest_point_index,
double maximum_distance
) const
{
int i;
bool rc = ON_GetClosestPointInPointList( m_count, m_a , P, &i );
if (rc)
{
if ( maximum_distance > 0.0 && P.DistanceTo(m_a[i]) > maximum_distance... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movl 0x10(%rcx), %edi
movq 0x8(%rcx), %rsi
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, ... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_PointCloud::RandomSubsample(ON_PointCloud const*, unsigned int, ON_PointCloud*, ON_ProgressReporter*, ON_Terminator*) | ON_PointCloud* ON_PointCloud::RandomSubsample(
const ON_PointCloud* source_point_cloud,
const unsigned int subsample_point_count,
ON_PointCloud* destination_point_cloud,
ON_ProgressReporter* progress_reporter,
ON_Terminator* terminator
)
{
if (
nullptr == source_point_cloud
|| subsample_point_co... | pushq %rbp
movq %rsp, %rbp
subq $0xa50, %rsp # imm = 0xA50
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x6f3d6e
cmpl $0x0, -0x14(%rbp)
jbe 0x6f3d6e
movl -0x14(%rbp), %eax
movl %eax, -0xa24(%rbp)
mo... | /mcneel[P]opennurbs/opennurbs_pointcloud.cpp |
ON_Point::Read(ON_BinaryArchive&) | bool ON_Point::Read( ON_BinaryArchive& file )
{
int major_version = 0;
int minor_version = 0;
bool rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc && major_version==1) {
// common to all 1.x versions
rc = file.ReadPoint(point);
}
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x328980
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%... | /mcneel[P]opennurbs/opennurbs_pointgeometry.cpp |
ON_PointGrid::Create(int, int) | bool
ON_PointGrid::Create(
int point_count0, // cv count0 (>= order0)
int point_count1 // cv count1 (>= order1)
)
{
if ( point_count0 < 1 )
return false;
if ( point_count1 < 1 )
return false;
m_point_count[0] = point_count0;
m_point_count[1] = point_count1;
m_point_stride0 =... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x6f5796
movb $0x0, -0x1(%rbp)
jmp 0x6f57d2
cmpl $0x1, -0x18(%rbp)
jge 0x6f57a2
movb $0x0, -0x1(%rbp)
jmp 0x6f57d2
movq -0x20(%rbp), %... | /mcneel[P]opennurbs/opennurbs_pointgrid.cpp |
ON_PointGrid::GetPoint(int, int, ON_3dPoint&) const | bool ON_PointGrid::GetPoint( int i, int j, ON_3dPoint& point ) const
{
bool rc = false;
if ( 0 <= i && i < m_point_count[0] && 0 <= j && j < m_point_count[1] ) {
point = m_point[i*m_point_stride0+j];
rc = true;
}
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x6f5ca3
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
j... | /mcneel[P]opennurbs/opennurbs_pointgrid.cpp |
ON_PointGrid::Transform(ON_Xform const&) | bool ON_PointGrid::Transform( const ON_Xform& xform )
{
TransformUserData(xform);
return ON_TransformPointGrid( 3, false,
m_point_count[0], m_point_count[1],
m_point_stride0*3, 3,
Point(0,0),
xform );
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x313470
movq -0x28(%rbp), %rdi
movl 0x10(%rdi), %eax
movl %eax, -0x1c(%rbp)
movl 0x14(%rdi), %eax
movl %eax, -0x18(%rbp)
imull $0x3, 0x18(%rdi), %eax
movl %... | /mcneel[P]opennurbs/opennurbs_pointgrid.cpp |
ON_PolyCurve::IsDeformable() const | bool ON_PolyCurve::IsDeformable() const
{
bool rc = true;
const int count = Count();
int segment_index;
for ( segment_index = 0; segment_index < count ; segment_index++ )
{
const ON_Curve* seg = m_segment[segment_index];
if ( seg && !seg->IsDeformable() )
{
rc = false;
break;
}
}... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x1, -0x9(%rbp)
callq 0x33a550
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6f6d71
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %esi
call... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::IsValid(bool, ON_TextLog*) const | bool ON_PolyCurve::IsValid( bool bAllowGaps, ON_TextLog* text_log ) const
{
const int count = Count();
const int dim = Dimension();
ON_3dPoint p0, p1;
int segment_index;
if ( count <= 0 || dim <= 0 )
{
if ( text_log )
text_log->Print("Polycurve segment count = %d and dim = %d\n",count,dim);
re... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x33a550
movq -0xa8(%rbp), %rdi
movl %eax, -0x24(%rbp)
movq (%rdi), %rax
callq *0xc0(%rax)
movl %eax, -0x28(%rbp)
cmpl $0x0, -... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::Read(ON_BinaryArchive&) | bool ON_PolyCurve::Read(
ON_BinaryArchive& file // open binary file
)
{
// NOTE - if changed, check legacy I/O code
Destroy();
int major_version = 0;
int minor_version = 0;
bool rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc)
{
ON_Object* obj;
ON_Curve* cr... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x312c00
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x328980
andb $0x1, %al
movb %al, -0x19(%rbp)
test... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::DuplicateCurve() const | ON_Curve* ON_PolyCurve::DuplicateCurve() const
{
// Call DuplicateCurve on each segment to construct duplicate curve.
int cnt = Count();
ON_PolyCurve* dup_crv = new ON_PolyCurve( cnt );
dup_crv->CopyUserData(*this);
for( int i=0; i<cnt; i++){
const ON_Curve* seg = SegmentCurve(i);
if(seg)
dup_crv->Append( ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x33a550
movl %eax, -0xc(%rbp)
movl $0x40, %edi
callq 0x3003f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x2fe070
jmp 0x6f80ba
movq -0x40(%rbp), %rsi
movq -0x38(%... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::Domain() const | ON_Interval ON_PolyCurve::Domain() const
{
ON_Interval d;
const int count = Count();
if ( count > 0 && count+1 == m_t.Count() && m_t[0] < m_t[count] ) {
d.Set(m_t[0],m_t[count]);
}
return d;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x312500
movq -0x28(%rbp), %rdi
callq 0x33a550
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x6f83a3
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax,... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::Degree() const | int ON_PolyCurve::Degree() const
{
const int segment_count = Count();
int span_degree = 0;
int segment_index, d;
for ( segment_index = 0; segment_index < segment_count; segment_index++ ) {
if ( !m_segment[segment_index] )
return false;
d = m_segment[segment_index]->Degree();
if ( d <= 0 )
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x33a550
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6f917a
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %esi
c... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
GetTestPlane(ON_Curve const&, ON_Plane&) | static bool GetTestPlane( const ON_Curve& curve, ON_Plane& plane )
{
int i, j;
ON_3dPoint P, Q, R;
ON_3dVector X;
ON_Interval d = curve.Domain();
if ( !curve.Ev1Der( d[0], P, X ) )
{
return false;
}
if ( !X.Unitize() )
{
return false;
}
Q = P+X;
double best_dot = 1.0;
ON_3dPoint best_... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x128(%rax)
movsd %xmm0, -0x90(%rbp)
movsd %xmm1, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
callq 0x... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::IsClosed() const | bool
ON_PolyCurve::IsClosed() const
{
bool bIsClosed = false;
const int count = Count();
if ( count == 1 ) {
// evaluation test required
const ON_Curve* c = FirstSegmentCurve();
if ( c )
bIsClosed = c->IsClosed();
}
else if ( count > 1 )
{
// 17 May2005 Dale Lear
// I added the... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x33a550
movl %eax, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0x6fa46e
movq -0x20(%rbp), %rdi
callq 0x338290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6fa46c
movq -0x18(%rbp),... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
LineLineTieBreaker(ON_Line const&, ON_Line const&, ON_3dPoint&, ON_3dPoint&) | static void LineLineTieBreaker( const ON_Line& line0, const ON_Line& line1,
ON_3dPoint& Q0, ON_3dPoint& Q1 )
{
double line0_length = line0.Length();
double line1_length = line1.Length();
ON_3dPoint C0, C1;
bool bHaveIsoCoords0 = GetLineIsoCoordinates(line0,Q0,C0);
bool bHaveI... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3323c0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3323c0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %r... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
SetLineIsoCoords(ON_Line const&, ON_3dPoint const&, ON_3dPoint&) | static void SetLineIsoCoords( const ON_Line& line, const ON_3dPoint& P, ON_3dPoint& Q )
{
ON_3dPoint C;
if ( GetLineIsoCoordinates(line,P,C) )
{
if ( ON_UNSET_VALUE != C.x && ON_IsValid(C.x) )
Q.x = P.x;
if ( ON_UNSET_VALUE != C.y && ON_IsValid(C.y) )
Q.y = P.y;
if ( ON_UNSET_VALUE != C.z ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x48(%rbp), %rax
leaq -0x30... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::HasGapAt(int) const | bool ON_PolyCurve::HasGapAt(int segment_index) const
{
const int count = m_segment.Count();
if ( segment_index < 0 || segment_index >= count-1 )
return 0;
const ON_Curve* c0 = m_segment[segment_index];
const ON_Curve* c1 = m_segment[segment_index+1];
if ( 0 == c0 || 0 == c1 )
return false;
ON_3dP... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x10, %rdi
callq 0x31e950
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6fb29c
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x6fb2a5
movb... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::IsContinuous(ON::continuity, double, int*, double, double, double, double, double) const | bool ON_PolyCurve::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_toleranc... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm3, -0x40(%rbp)
movsd %xmm4, -0x48(%rbp)
movsd %xmm5, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq %rd... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::Insert(int, ON_Curve*) | bool ON_PolyCurve::Insert( int segment_index, ON_Curve* c )
{
double s0, s1;
bool rc = false;
const int count = Count();
if ( segment_index >= 0 && segment_index <= count && c && c != this &&
c->GetDomain(&s0,&s1) )
{
rc = true;
if (count > 0 && c->Dimension() != Dimension()) // 1-Sept-2017 (GBA) D... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movb $0x0, -0x29(%rbp)
callq 0x33a550
movl %eax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7001d6
movl -0xc(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0x7001d6
cmpq $0x0, -... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::SegmentIndex(ON_Interval, int*, int*) const | int ON_PolyCurve::SegmentIndex(
ON_Interval sub_domain,
int* segment_index0,
int* segment_index1
) const
{
const int segment_count = m_segment.Count();
int s0 = 0, s1 = 0;
ON_Interval seg_dom;
sub_domain.Intersection( Domain() );
if ( sub_domain.IsIncreasing() )
{
s0 = SegmentIndex(sub_domain.Mi... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x10, %rdi
callq 0x31e950
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x48(... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::GetNurbFormParameterFromCurveParameter(double, double*) const | bool ON_PolyCurve::GetNurbFormParameterFromCurveParameter(
double curve_t,
double* nurbs_t
) const
{
bool rc = false;
int i = SegmentIndex( curve_t );
const ON_Curve* curve = SegmentCurve(i);
if ( curve ) {
ON_Interval in( m_t[i], m_t[i+1] );
ON_Interval cdom = curve->Domain();
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movb $0x0, -0x19(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x312290
movq -0x50(%rbp), %rdi
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x31f030
movq %rax, -0x... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::Trim(ON_Interval const&) | bool ON_PolyCurve::Trim(
const ON_Interval& domain
)
{
// Please talk to Dale Lear before you change code in this function.
// m_t[] = Increasing array of segment_count+1 parameter values
// that specify segment domains.
// Domain of polycurve = (m_t[0],m_t[segment_count]).
// m_segment... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x158(%rbp)
addq $0x10, %rdi
callq 0x31e950
movq -0x158(%rbp), %rdi
movl %eax, -0x1c(%rbp)
addq $0x28, %rdi
callq 0x334f30
cmpl $0x2, %eax
jl 0x701154
movq -0x158(%rbp),... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_PolyCurve::SynchronizeSegmentDomains() | bool ON_PolyCurve::SynchronizeSegmentDomains()
{
double t0, t1;
int i, count = m_segment.Count();
ON_Curve** c = m_segment.Array();
if ( count < 1 || 0 == c )
return false;
if ( count+1 != m_t.Count() )
return false;
const double* t = m_t.Array();
if ( 0 == t )
return false;
bool rc = false... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x10, %rdi
callq 0x31e950
movq -0x48(%rbp), %rdi
movl %eax, -0x28(%rbp)
addq $0x10, %rdi
callq 0x334b10
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x28(%rbp)
jl 0x70380f
xorl %eax, %eax
cmpq -0x30(%rbp), %rax
... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
GetLineIsoCoordinates(ON_Line const&, ON_3dPoint, ON_3dPoint&) | static bool GetLineIsoCoordinates( const ON_Line& line, const ON_3dPoint P, ON_3dPoint& C )
{
C.x = (line.from.x == line.to.x) ? P.x : ON_UNSET_VALUE;
C.y = (line.from.y == line.to.y) ? P.y : ON_UNSET_VALUE;
C.z = (line.from.z == line.to.z) ? P.z : ON_UNSET_VALUE;
return ( ON_3dPoint::UnsetPoint != C );
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jne 0x703dec
jp 0x703dec
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp... | /mcneel[P]opennurbs/opennurbs_polycurve.cpp |
ON_SimpleArray<ON_Curve*>::Reverse() | void ON_SimpleArray<T>::Reverse()
{
// NOTE:
// If anything in "T" depends on the value of this's address,
// then don't call Reverse().
T t;
int i = 0;
int j = m_count-1;
for ( /*empty*/; i < j; i++, j-- ) {
t = m_a[i];
m_a[i] = m_a[j];
m_a[j] = t;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x7040d8
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rd... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<double>::Insert(int, double 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 0x7042f2
movq -0x38(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x7042f2
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq ... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_PolyEdgeSegment::DuplicateCurve() const | ON_Curve* ON_PolyEdgeSegment::DuplicateCurve() const
{
return ON_CurveProxy::DuplicateCurve();
// 21 December 2004 Dale Lear
// This is wrong. I did it some time ago as a quick
// fix for one of Lowell's early uses of CRhinoPolyEdges
// however, this will cause lots of crashes now that
// ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x308ad0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_polyedgecurve.cpp |
ON_PolyEdgeCurve::Create(ON_BrepTrim const*, ON_UUID_struct const&) | bool ON_PolyEdgeCurve::Create( const ON_BrepTrim* trim, const ON_UUID& object_id )
{
bool rc = false;
Destroy();
//m_is_closed_helper = 0;
if ( trim )
{
ON_PolyEdgeSegment* segment = new ON_PolyEdgeSegment();
rc = segment->Create(trim,object_id);
if (rc )
Append(segment);
else
dele... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x312c00
cmpq $0x0, -0x10(%rbp)
je 0x705e66
movl $0x198, %edi # imm = 0x198
callq 0x3003f0
movq %rax, %rdi
movq %rdi, %rax
... | /mcneel[P]opennurbs/opennurbs_polyedgecurve.cpp |
ON_PolyEdgeCurve::Prepend(ON_PolyEdgeSegment*) | bool ON_PolyEdgeCurve::Prepend( ON_PolyEdgeSegment* new_segment )
{
DestroyRuntimeCache();
bool rc = false;
if ( new_segment )
{
if ( Count() > 0 )
{
// keep segment domains in synch with polycurve domain
// so that parameter bookkeeping is easy.
ON_Interval cdom = Domain();
ON_I... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq (%rdi), %rax
movl $0x1, %esi
callq *0xb8(%rax)
movb $0x0, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x70615a
movq -0x40(%rbp), %rdi
callq 0x33a550
cmpl $0x0, %eax
jle 0x706148
movq -0x4... | /mcneel[P]opennurbs/opennurbs_polyedgecurve.cpp |
ON_PolyEdgeCurve::ContainsAllEdges() const | bool ON_PolyEdgeCurve::ContainsAllEdges() const
{
int i, count = SegmentCount();
for( i = 0; i < count; i++)
{
ON_PolyEdgeSegment* segment = SegmentCurve(i);
if( nullptr == segment || nullptr == segment->BrepEdge())
{
return false;
}
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x324f40
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x706689
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x307c60
movq %rax, -0x20(%rbp)
xor... | /mcneel[P]opennurbs/opennurbs_polyedgecurve.cpp |
ON_PolyEdgeCurve::FindTrim(ON_BrepTrim const*) const | int ON_PolyEdgeCurve::FindTrim( const ON_BrepTrim* trim) const
{
int rc = -1;
if ( 0 != trim )
{
int i, count = SegmentCount();
for( i = 0; i < count; i++)
{
ON_PolyEdgeSegment* segment = SegmentCurve(i);
if ( 0 != segment && trim == segment->BrepTrim() )
{
rc = i;
br... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x7067ce
movq -0x30(%rbp), %rdi
callq 0x324f40
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
mo... | /mcneel[P]opennurbs/opennurbs_polyedgecurve.cpp |
ON_PolyEdgeSegment::Write(ON_BinaryArchive&) const | bool ON_PolyEdgeSegment::Write( ON_BinaryArchive& archive ) const
{
bool rc = archive.BeginWrite3dmChunk(TCODE_ANONYMOUS_CHUNK,1,0);
if (!rc)
return false;
for(;;)
{
rc = archive.WriteUuid(m_object_id);
if (!rc) break;
rc = archive.WriteComponentIndex(m_component_index);
if (!rc) break;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl $0x40008000, %esi # imm = 0x40008000
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x305e30
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0... | /mcneel[P]opennurbs/opennurbs_polyedgecurve.cpp |
ON_PolyEdgeCurve::operator=(ON_PolyEdgeCurve const&) | class ON_CLASS ON_PolyEdgeCurve : public ON_PolyCurve
{
ON_OBJECT_DECLARE(ON_PolyEdgeCurve);
public:
ON_PolyEdgeCurve();
~ON_PolyEdgeCurve();
// default copy constructor and operator= are fine.
// virtual ON_Object::DestroyRuntimeCache override
void DestroyRuntimeCache( bool bDelete = true ) override;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x312a90
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_polyedgecurve.h |
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.