name string | code string | asm string | file string |
|---|---|---|---|
ON_Mesh::EvaluateMeshGeometry(ON_Surface const&) | bool ON_Mesh::EvaluateMeshGeometry( const ON_Surface& srf )
{
bool rc = false;
const int vcount = VertexCount();
const bool bHasSurfaceParameters = HasSurfaceParameters();
if ( bHasSurfaceParameters )
{
const bool bHasDoublePrecisionVertices = this->HasDoublePrecisionVertices();
if (false == bHasDoubl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
movb $0x0, -0x29(%rbp)
callq 0x3385a0
movq -0x1c0(%rbp), %rdi
movl %eax, -0x30(%rbp)
callq 0x31bf50
andb $0x1, %al
movb %al,... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::Cleanup(bool, bool, bool) | void ON_Mesh::Cleanup(
bool bRemoveNgons,
bool bRemoveDegenerateFaces,
bool bCompact
)
{
V4V5_DestroyNgonList(); // old junk
if ( bRemoveNgons )
SetNgonCount(0);
if (bRemoveDegenerateFaces)
CullDegenerateFaces();
DestroyRuntimeCache(true);
if ( bCompact )
Compact();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %cl
movb %cl, -0xa(%rbp)
andb $0x1, %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x329b20
testb $0x1, -0x9(%rbp)
je 0x620292
movq -0x... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_SurfaceCurvature::CreateFromGaussianAndMeanCurvatures(double, double) | const ON_SurfaceCurvature ON_SurfaceCurvature::CreateFromGaussianAndMeanCurvatures(
double gaussian_curvature,
double mean_curvature
)
{
if (ON_IS_VALID(gaussian_curvature) && ON_IS_VALID(mean_curvature))
{
const double r = mean_curvature * mean_curvature - gaussian_curvature;
if (r >= 0.0)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x2b3409(%rip), %xmm1 # 0x8d3768
ucomisd %xmm1, %xmm0
jbe 0x6204d1
movsd 0x2be257(%rip), %xmm0 # 0x8de5c8
ucomisd -0x18(%rbp), %xmm0
jbe 0x6204d1
movsd -0x20(%rbp), %xmm0
movsd 0x2b33df(%rip)... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshTopology::TopEdgeLine(int) const | ON_Line ON_MeshTopology::TopEdgeLine( int tope_index ) const
{
ON_Line L(ON_3dPoint::UnsetPoint,ON_3dPoint::UnsetPoint);
if ( m_mesh && tope_index >= 0 && tope_index < m_tope.Count() )
{
const int* topvi = m_tope[tope_index].m_topvi;
if ( topvi[0] >= 0 && topvi[0] < m_topv.Count()
&& topvi[1] >... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0x15(%rbp)
movq 0x45ca73(%rip), %rax # 0xa7dc60
movq (%rax)... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshTopology::GetIntArray(int) | int* ON_MeshTopology::GetIntArray(int length)
{
int* a = 0;
if ( length > 0 ) {
struct memchunk* pm;
pm = (struct memchunk*)onmalloc(length*sizeof(*a) + sizeof(*pm));
if ( pm ) {
pm->next = m_memchunk;
m_memchunk = pm++;
a = (int*)pm;
}
}
return a;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x62231d
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
addq $0x8, %rdi
callq 0x307b10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x62231b
... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::GetVertexLocationIds(unsigned int, unsigned int*, unsigned int*) const | unsigned int* ON_Mesh::GetVertexLocationIds(
unsigned int first_vid,
unsigned int* Vid,
unsigned int* Vindex
) const
{
const unsigned int vertex_count = VertexUnsignedCount();
return (HasSynchronizedDoubleAndSinglePrecisionVertices())
? ON_GetPointLocationIds(vertex_count, m_dV.Array(), first_vid, Vid, ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x32c2e0
movq -0x30(%rbp), %rdi
movl %eax, -0x24(%rbp)
callq 0x335480
testb $0x1, %al
jne 0x623b86
jmp 0x623bb7
movq -0x30(%rbp), %rdi
... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
AddToPartition(ON_Mesh*, ON_SimpleArray<int>&, int, int, int) | static int AddToPartition( ON_Mesh* mesh, ON_SimpleArray<int>& pmark, int vi, int partition_mark, int fi0 )
{
bool b = true;
int i, fi, new_vi, face_count, *fvi;
i = pmark[vi];
if ( !i ) {
pmark[vi] = partition_mark;
}
else if ( i != partition_mark && i != partition_mark-1 ) {
if ( i == partition_ma... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movb $0x1, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x312950
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x624d51
m... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::MeshPart(ON_MeshPart const&, ON_Mesh*) const | ON_Mesh* ON_Mesh::MeshPart(
const ON_MeshPart& mesh_part,
ON_Mesh* mesh
) const
{
if ( this == mesh )
{
ON_ERROR("ON_Mesh::MeshPart this == mesh");
return 0;
}
if ( mesh )
mesh->Destroy();
if ( mesh_part.fi[0] < 0
|| mesh_part.fi[1] > m_F.Count()
|| mesh_part.fi[0] > me... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq -0x20(%rbp), %rax
jne 0x625086
leaq 0x2d950e(%rip), %rdi # 0x8fe56d
movl $0x2dbf, %esi # imm = 0x2DBF
leaq 0x2ef2d6(%rip), %rdx # 0x914341
l... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshComponentRef::IsValid(ON_TextLog*) const | bool ON_MeshComponentRef::IsValid( ON_TextLog* text_log ) const
{
if ( 0 == m_mesh)
{
if ( 0 != text_log )
{
text_log->Print("m_mesh = nullptr.\n");
}
return false;
}
if ( false == m_mesh_ci.IsMeshComponentIndex() )
{
if ( 0 != text_log )
{
text_log->Print("m_mesh_ci = ");... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x626373
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x62636a
movq -0x18(%rbp), %rdi
leaq 0x2d90e5(%rip), %rsi # 0x8ff448
movb $0x0, %al
call... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshComponentRef::GetMeshTopologyEdgeAndLine(ON_MeshTopologyEdge const*&, ON_Line&) const | unsigned int ON_MeshComponentRef::GetMeshTopologyEdgeAndLine(
const struct ON_MeshTopologyEdge*& tope,
ON_Line& line
) const
{
tope = 0;
unsigned int topei = GetMeshTopologyEdge(tope);
if ( ON_UNSET_UINT_INDEX != topei && 0 != tope && tope->m_topvi[0] >= 0 && tope->m_topvi[1] >= 0 )
{
const ON_MeshTo... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rsi
callq 0x333160
movl %eax, -0x24(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl -0x24(... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::MeshComponent(ON_COMPONENT_INDEX) const | ON_MeshComponentRef* ON_Mesh::MeshComponent(
ON_COMPONENT_INDEX ci
) const
{
ON_MeshComponentRef* cr_ptr = 0;
ON_MeshComponentRef cr = MeshComponentRef(ci);
if ( this == cr.Mesh() && cr.ComponentIndex() == ci )
cr_ptr = new ON_MeshComponentRef(cr);
return cr_ptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x3378e0
leaq -0x38(%rbp), %rdi
callq 0x2faf60
movq -0x60(%rbp), ... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::VertexIsHidden(int) const | bool ON_Mesh::VertexIsHidden(int meshvi) const
{
const int vcount = m_V.Count();
return ((m_hidden_count > 0 && meshvi >= 0 && meshvi < vcount && vcount == m_H.Count())
? m_H[meshvi]
: false);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x28, %rdi
callq 0x328f90
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0x378(%rax)
jle 0x628659
cmpl $0x0, -0xc(%rbp)
jl 0x628659
movl -0xc(%rbp), %eax
c... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshTopology::TopVertexIsHidden(int) const | bool ON_MeshTopology::TopVertexIsHidden( int topvi ) const
{
const bool* bHiddenVertex = m_mesh ? m_mesh->HiddenVertexArray() : 0;
if ( bHiddenVertex && topvi >= 0 && topvi < m_topv.Count() )
{
const ON_MeshTopologyVertex& topv = m_topv[topvi];
int i;
for ( i = 0; i < topv.m_v_count; i++ )
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0x62875f
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x309cf0
movq %rax, -0x40(%rbp)
jmp 0x628767
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x628767
movq -0x40... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_SurfaceCurvatureColorMapping::ON_SurfaceCurvatureColorMapping(ON::curvature_style, ON_Interval) | ON_SurfaceCurvatureColorMapping::ON_SurfaceCurvatureColorMapping(
ON::curvature_style kappa_style,
ON_Interval kappa_range
)
: m_is_set(2)
, m_kappa_style(ON::CurvatureStyle((int)(kappa_style)))
, m_kappa_range(kappa_range.IsValid() ? kappa_range : ON_Interval::Nan)
{} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x2, (%rax)
movb $0x0, 0x1(%rax)
movw $0x0, 0x2(%rax)
movl -0x1c(%rbp), %edi
callq 0x307b70
movl %eax, %ecx
movq -0x30(%rbp), %ra... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MappingTag::ON_MappingTag(ON_TextureMapping const&, ON_Xform const*) | ON_MappingTag::ON_MappingTag(const ON_TextureMapping & mapping, const ON_Xform * xform)
{
Default();
Set(mapping);
if ( false == ON_MappingTag::TransformTreatedIsIdentity(xform))
m_mesh_xform = *xform;
} | 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 0x45339d(%rip), %rax # 0xa7c8b0
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
a... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
operator!=(ON_MappingTag const&, ON_MappingTag const&) | bool operator!=(const ON_MappingTag& lhs, const ON_MappingTag& rhs)
{
if (lhs.m_mapping_type != rhs.m_mapping_type || false == (lhs.m_mapping_id == rhs.m_mapping_id))
return true;
if (ON_TextureMapping::TYPE::no_mapping == lhs.m_mapping_type && ON_nil_uuid == lhs.m_mapping_id)
{
// m_mapping_crc and m_me... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x6298a8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3388b0
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jn... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_V5_MeshDoubleVertices::Read(ON_BinaryArchive&) | bool ON_V5_MeshDoubleVertices::Read(ON_BinaryArchive& file)
{
m_fcount = 0;
m_dcount = 0;
m_fCRC = 0;
m_dCRC = 0;
m_V5_dV.Destroy();
int major_version = 0;
int minor_version = 0;
bool rc = file.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version);
if (!rc)
return false;
for(;;... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, 0xc8(%rdi)
movl $0x0, 0xcc(%rdi)
movl $0x0, 0xd0(%rdi)
movl $0x0, 0xd4(%rdi)
addq $0xd8, %rdi
callq 0x338070
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), ... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_PerObjectMeshParameters::Read(ON_BinaryArchive&) | bool ON_PerObjectMeshParameters::Read(ON_BinaryArchive& binary_archive)
{
m_mp = ON_MeshParameters::FastRenderMesh;
m_mp.SetCustomSettings(true);
m_mp.SetComputeCurvature(false);
int major_version = 0;
int minor_version = 0;
if ( !binary_archive.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0xc8, %rdi
movq 0x4523ba(%rip), %rsi # 0xa7d4a0
movl $0xe0, %edx
callq 0x2fcd50
movq -0x40(%rbp), %rdi
addq $0xc8, %rdi
movl $0x1, %esi
callq 0x315f90
movq -0x40(%rbp), %rdi
a... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
Internal_FaceDegenerateAreaCheck(ON_MeshFace&, int, ON_3fPoint const*, ON_3dPoint const*) | static int Internal_FaceDegenerateAreaCheck(
ON_MeshFace& f,
int vertex_count,
const ON_3fPoint* fV,
const ON_3dPoint* dV
)
{
// returns:
// 0: f is degenerate
// 1: f is not degenerate
// 2: f was a degenerate quad and fixed to be a good triangle
ON_3dPoint V[4];
double a[2];
const double atol = ... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movsd 0x2cfcc6(%rip), %xmm0 # 0x8fe108
movsd %xmm0, -0xa8(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x62e508
movq -0x28(%rbp), %rax
movq -0x10(%rbp), ... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::SetSurfaceParamtersFromTextureCoodinates() | bool ON_Mesh::SetSurfaceParamtersFromTextureCoodinates()
{
unsigned int i;
const unsigned int vcount = m_V.UnsignedCount();
bool rc;
ON_Interval dom;
if (vcount == m_T.UnsignedCount())
{
dom.Set(0.0, 1.0);
m_S.SetCount(0);
m_S.Reserve(vcount);
for (i = 0; i < vcount; i++)
{
ON_2dP... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x28, %rdi
callq 0x325150
movl %eax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x312500
movq -0x48(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x3c(%rbp)
addq $0x1f8, %rdi # imm = 0x1F8
call... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshCache::MeshIdFromMeshType(ON::mesh_type) | ON_UUID ON_MeshCache::MeshIdFromMeshType(
ON::mesh_type mesh_type
)
{
switch (mesh_type)
{
case ON::default_mesh:
return ON_MeshCache::CoarseMeshId;
break;
case ON::render_mesh:
return ON_MeshCache::RenderMeshId;
break;
case ON::analysis_mesh:
return ON_MeshCache::AnalysisMeshId;
b... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x630684
movq -0x20(%rbp), %rax
leaq 0x2cdcf9(%rip), %rcx # 0x8fe2fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x44bde5(%rip), %rax # 0xa7c3f8
movq (%rax), %rcx
movq %rcx, -0x10(%rbp... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshCache::Internal_CopyItem(ON_MeshCacheItem const&) | class ON_MeshCacheItem* ON_MeshCache::Internal_CopyItem(const class ON_MeshCacheItem& src_item)
{
// Items must come from the main memory pool to prevent
// crashing when meshing operations are canceled.
// Use placement operator new with main heap memory.
ON_MeshCacheItem* item;
void* p = onmalloc(sizeof(*it... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x307b10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x31c740
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
m... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshCache::Internal_CopyHelper(ON_MeshCacheItem const*) | void ON_MeshCache::Internal_CopyHelper(
const class ON_MeshCacheItem* src_impl
)
{
m_impl = 0;
ON_MeshCacheItem* prev = nullptr;
for (const ON_MeshCacheItem* src_item = src_impl; nullptr != src_item; src_item = src_item->m_next)
{
ON_MeshCacheItem* item_copy = Internal_CopyItem(*src_item);
if (nullp... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x63081f
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
ca... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshCache::ClearAllMeshes(bool) | void ON_MeshCache::ClearAllMeshes(bool bDeleteMesh)
{
if ( 0 != m_impl )
{
ON_MeshCacheItem* next = m_impl;
m_impl = nullptr;
for (ON_MeshCacheItem* item = next; nullptr != item; item = next)
{
next = item->m_next;
Internal_DeleteItem(item,bDeleteMesh);
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x630e42
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %r... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshRef::SetMeshForExperts(ON_Mesh*&) | class ON_Mesh* ON_MeshRef::SetMeshForExperts(
class ON_Mesh*& mesh
)
{
Clear();
ON_Mesh* managed_mesh = ( mesh == &ON_Mesh::Empty ) ? nullptr : mesh;
mesh = nullptr;
if (nullptr != managed_mesh )
m_mesh_sp = std::shared_ptr<class ON_Mesh>(managed_mesh);
return managed_mesh;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3370f0
movq -0x10(%rbp), %rax
movq 0x44d8b0(%rip), %rcx # 0xa7ef38
cmpq %rcx, (%rax)
jne 0x631695
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x6316a0
movq -0x10(%rbp), %rax
mo... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
Internal_GrowNgon(ON_MeshTopology const&, unsigned char*, unsigned char*, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, ON_SimpleArray<unsigned int>&) | static void Internal_GrowNgon(
const ON_MeshTopology& top,
unsigned char* emarks,
unsigned char* fmarks,
unsigned char etest_mask,
unsigned char etest_result,
unsigned char ftest_mask,
unsigned char ftest_result,
const unsigned char merged_mark,
ON_SimpleArray<unsigned>& ngon_fi
)
{
if (ngon_fi.Coun... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %r8d, -0x78(%rbp)
movl %ecx, %eax
movl -0x78(%rbp), %ecx
movl %eax, -0x74(%rbp)
movq %rdx, %rax
movl -0x74(%rbp), %edx
movq %rax, -0x70(%rbp)
movq %rsi, %rax
movq -0x70(%rbp), %rsi
movq %rax, -0x68(%rbp)
movq %rdi, %r8
movq -0x68(%rbp), %rdi
movb %r9b, %al
movq 0x20(%rbp... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
WcsMappingId(ON_Xform const&, bool) | static ON_UUID WcsMappingId(const ON_Xform& ocsTransform, bool bBox)
{
// {47D62129-341E-4E3D-BF11-9C051AF4ED98}
static const ON_UUID uuidBaseWcs =
{ 0x47d62129, 0x341e, 0x4e3d, { 0xbf, 0x11, 0x9c, 0x5, 0x1a, 0xf4, 0xed, 0x98 } };
// {4DC9AA78-9617-46FB-923F-3E65E14182FC}
static const ON_UUID uuidBaseWcsBox ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x636237
leaq 0x2c81ef(%rip), %rax # 0x8fe420
movq %rax, -0x28(%rbp)
jmp 0x636244
leaq 0x2c81d2(%rip), %rax # 0x8fe410
movq %rax, -0x28(%rbp)
jmp 0x636244
movq -0x28(%r... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_ClassArray<ON_TextureCoordinates>::operator=(ON_ClassArray<ON_TextureCoordinates> const&) | ON_ClassArray<T>& ON_ClassArray<T>::operator=( const ON_ClassArray<T>& src )
{
int i;
if( this != &src ) {
if ( src.m_count <= 0 ) {
m_count = 0;
}
else {
if ( m_capacity < src.m_count ) {
SetCapacity( src.m_count );
}
if ( m_a ) {
m_count = src.m_count;
f... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x63871b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jg 0x63868c
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x638719
movq -0x20(%rbp), %rax
movl 0x14(%ra... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_3dPointListRef::operator[](int) const | inline ON_3dPoint operator[](int point_index) const
{
double buffer[3];
if ( point_index >= 0 && ((unsigned int)point_index) < m_point_count )
{
if ( m_dP )
{
const double* p = m_dP + (point_index*m_point_stride);
buffer[0] = *p++;
buffer[1] = *p++;
buffer[2] ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x639bd1
movq -0x48(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jae 0x639bd1
movq -0x48(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0... | /mcneel[P]opennurbs/opennurbs_point.h |
ON_SimpleArray<ON_MeshTopologyVertex>::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 0x63aa42
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x63aa5d
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<int>::Permute(int const*) | bool ON_SimpleArray<T>::Permute( const int* index )
{
bool rc = false;
if ( m_a && m_count > 0 && index ) {
int i;
T* buffer = (T*)onmalloc(m_count*sizeof(buffer[0]));
memcpy( (void*)(buffer), (void*)(m_a), m_count*sizeof(T) );
for (i = 0; i < m_count; i++ )
memcpy( (void*)(m_a+i), (void*)(buf... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x63b7ea
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x63b7ea
cmpq $0x0, -0x10(%rbp)
je 0x63b7ea
movq -0x28(%rbp), %rax
movslq 0x10(%r... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_MeshNgon*>::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 0x63d142
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x63d15d
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_MeshNgon*>::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 0x63d782
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x63d7aa
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_MeshTopologyEdge>::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 0x63f1c2
cmpl $0x0, -0x10(%rbp)
jl 0x63f1c2
cmpl $0x0, -0xc(%rbp)
jl 0x63f1c2
movl -0x10(%rbp), %eax
cmpl -0xc(%rb... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_MeshModifier::AddChildXML(ON_XMLRootNode&) const | ON_XMLNode* ON_MeshModifier::AddChildXML(ON_XMLRootNode& root) const
{
ON_XMLNode* mm_node = root.AttachChildNode(new ON_XMLNode(L""));
if (nullptr != mm_node)
{
*mm_node = m_impl->Node();
}
return mm_node;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0xe8, %edi
callq 0x3003f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x2a4971(%rip), %rsi # 0x8e481c
callq 0x32183... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_Displacement::operator==(ON_Displacement const&) const | bool ON_Displacement::operator == (const ON_Displacement& dsp) const
{
if (On() != dsp.On()) return false;
if (Texture() != dsp.Texture()) return false;
if (MappingChannel() != dsp.MappingChannel()) return false;
if (BlackPoin... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x31a880
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31a880
movb %al, %cl
movl -0x3c(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %e... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_Displacement::AddSubItem() | ON_Displacement::SubItem& ON_Displacement::AddSubItem(void)
{
ON_XMLNode node(ON_DISPLACEMENT_SUB);
auto* sub = new SubItem(node);
m_impl_dsp->m_subs.Append(sub);
return *sub;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq 0x2d09bb(%rip), %rsi # 0x913bdc
leaq -0xf0(%rbp), %rdi
callq 0x321830
movl $0x8, %edi
callq 0x3003f0
movq %rax, -0x110(%rbp)
jmp 0x643240
movq -0x110(%rbp), %rdi
leaq -0xf0(%... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_ThickeningUserData::SetToDefaults() const | void ON_ThickeningUserData::SetToDefaults(void) const
{
auto& ud = const_cast<ON_ThickeningUserData&>(*this);
ud.Clear();
ON_XMLProperty prop;
ON_XMLNode* root = ud.XMLRootForWrite().AttachChildNode(new ON_XMLNode(ON_THICKENING_ROOT));
ON_Thickening::Defaults d;
ON_XMLParameters p(*root);
p.SetParam(ON... | pushq %rbp
movq %rsp, %rbp
subq $0x5a0, %rsp # imm = 0x5A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x120(%rax), %rax
callq *%rax
leaq -0x78(%rbp), %rdi
callq 0x2fb9e0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0xf8(%rax), %rax
callq ... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_Thickening::operator==(ON_Thickening const&) const | bool ON_Thickening::operator == (const ON_Thickening& t) const
{
if (On() != t.On()) return false;
if (Distance() != t.Distance()) return false;
if (Solid() != t.Solid()) return false;
if (OffsetOnly() != t.OffsetOnly()) return false;
if (BothSides() != t.BothSides()) return fa... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3273f0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3273f0
movb %al, %cl
movl -0x1c(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %e... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_CurvePiping::operator=(ON_CurvePiping const&) | const ON_CurvePiping& ON_CurvePiping::operator = (const ON_CurvePiping& cp)
{
if (this != &cp)
{
SetRadius (cp.Radius());
SetSegments(cp.Segments());
SetFaceted (cp.Faceted());
SetAccuracy(cp.Accuracy());
SetCapType (cp.CapType());
}
return *this;
} | 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 0x6472e4
movq -0x10(%rbp), %rdi
callq 0x3138d0
movq -0x18(%rbp), %rdi
callq 0x319cd0
movq -0x10(%rbp), %rdi
callq 0x315cf0
movq -0x18(%rbp), %rdi
movl %eax, %es... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_ShutLiningUserData::SetToDefaults() const | void ON_ShutLiningUserData::SetToDefaults(void) const
{
auto& ud = const_cast<ON_ShutLiningUserData&>(*this);
ud.Clear();
ON_XMLProperty prop;
ON_XMLNode* root = ud.XMLRootForWrite().AttachChildNode(new ON_XMLNode(ON_SHUTLINING_ROOT));
ON_XMLParameters p(*root);
p.SetParam(ON_SHUTLINING_ON, false);
p.Se... | pushq %rbp
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x120(%rax), %rax
callq *%rax
leaq -0x78(%rbp), %rdi
callq 0x2fb9e0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0xf8(%rax), %rax
callq ... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_ShutLining::ON_ShutLining(ON_XMLNode const&) | ON_ShutLining::ON_ShutLining(const ON_XMLNode& sl_node)
{
m_impl_sl = new CImplSL;
// Iterate over the shut-lining node looking at each child node's name. If the child
// node is a curve node, create a curve object to hold the curve XML. Otherwise add
// a copy of the child node to a new shut-lining node.
ON... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x319070
movq -0x138(%rbp), %rax
movq 0x433dc7(%rip), %rcx # 0xa7c548
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x18, %edi
callq 0x3003f0
movq %rax, -0... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_ShutLining::AddCurve() | ON_ShutLining::Curve& ON_ShutLining::AddCurve(void)
{
ON_XMLNode* curve_node = m_impl->Node().AttachChildNode(new ON_XMLNode(ON_SHUTLINING_CURVE));
Curve* curve = new Curve(*curve_node);
m_impl_sl->m_curves.Append(curve);
return *curve;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%rax), %rdi
callq 0x2fe780
movq %rax, -0x38(%rbp)
movl $0xe8, %edi
callq 0x3003f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x2b8318(%rip), %rsi # 0x9016b4
callq 0x321830
jmp 0x64... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_ShutLining::FindCurve(ON_UUID_struct const&) const | ON_ShutLining::Curve* ON_ShutLining::FindCurve(const ON_UUID& id) const
{
auto it = GetCurveIterator();
while (Curve* curve = it.Next())
{
if (curve->Id() == id)
return curve;
}
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2fa1f0
leaq -0x20(%rbp), %rdi
callq 0x323e10
movq %rax, -0x50(%rbp)
jmp 0x64952c
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6495a6
movq -0x28(%rb... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_MeshModifiers::CImpl::LoadFromXML(ON_XMLRootNode const&) | void ON_MeshModifiers::CImpl::LoadFromXML(const ON_XMLRootNode& root)
{
auto it = root.GetChildIterator();
while (ON_XMLNode* child_node = it.GetNextChild())
{
const ON_wString& s = child_node->TagName();
if (ON_DISPLACEMENT_ROOT == s)
{
m_displacement = new ON_Displacement(*child_node);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
leaq -0x20(%rbp), %rdi
callq *0x160(%rax)
leaq -0x20(%rbp), %rdi
callq 0x31fae0
movq %rax, -0x50(%rbp)
jmp 0x64a70b
movq -0x50(%rbp), %rax
movq %... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_MeshModifiers::Displacement(bool) | ON_Displacement* ON_MeshModifiers::Displacement(bool allow_creation)
{
if ((nullptr == m_impl->m_displacement) && allow_creation)
m_impl->m_displacement = new ON_Displacement;
return m_impl->m_displacement;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x64ae83
testb $0x1, -0x9(%rbp)
je 0x64ae83
movl $0x18, %edi
callq 0x3003f0
movq %rax, %rdi
movq %rdi,... | /mcneel[P]opennurbs/opennurbs_mesh_modifiers.cpp |
ON_Thickening::~ON_Thickening() | class ON_CLASS ON_Thickening : public ON_MeshModifier
{
public:
ON_Thickening();
ON_Thickening(const ON_XMLNode& node);
ON_Thickening(const ON_Thickening& t);
const ON_Thickening& operator = (const ON_Thickening& t);
bool operator == (const ON_Thickening& t) const;
bool operator != (const ON_Thickening& t... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x301280
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x2fe340
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /mcneel[P]opennurbs/opennurbs_mesh_modifiers.h |
ON_MeshNgon::BoundaryEdgeCount(ON_MeshFaceList const&) const | unsigned int ON_MeshNgon::BoundaryEdgeCount(const ON_MeshFaceList & mesh_face_list) const
{
if (m_Fcount <= 0 || nullptr == m_fi)
return 0;
const unsigned int mesh_face_count = mesh_face_list.FaceCount();
if (mesh_face_count <= 0)
return 0;
const unsigned int edge_capacity = 4 * mesh_face_count;
ON_S... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpl $0x0, 0x4(%rax)
jbe 0x64cde3
movq -0x98(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x64cdef
movl $0x0, -0x4(%rbp)
jmp 0x64d01f
movq -0x18(%rbp), %rdi
callq 0x30d620
mov... | /mcneel[P]opennurbs/opennurbs_mesh_ngon.cpp |
ON_ClassArray<ON_CurveProxyHistory>::SetCapacity(unsigned long) | T* ON_ClassArray<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;
}
// uses "placement" fo... | 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 0x6acda2
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x6acdbd
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_SubDEdgeChain*>::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 0x6ad372
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x6ad39a
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_SubDEdgeChain const*>::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 0x6ad7f2
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x6ad80d
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_Geometry 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 0x6adb22
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x6adb4a
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_ClassArray<ON_CurveProxyHistory>::HeapSort(int (*)(ON_CurveProxyHistory const*, ON_CurveProxyHistory const*)) | bool ON_ClassArray<T>::HeapSort( int (*compar)(const T*,const T*) )
{
bool rc = false;
if ( m_a && m_count > 0 && compar )
{
if ( m_count > 1 )
ON_hsort( m_a, m_count, sizeof(T), (int(*)(const void*,const void*))compar );
rc = true;
}
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x6addec
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x6addec
cmpq $0x0, -0x10(%rbp)
je 0x6addec
movq -0x20(%rbp), %rax
cmpl $0x1, 0x1... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_COMPONENT_INDEX::Type(int) | ON_COMPONENT_INDEX::TYPE ON_COMPONENT_INDEX::Type(int i)
{
TYPE t = invalid_type;
switch((unsigned int)i)
{
case ON_COMPONENT_INDEX::no_type: t = ON_COMPONENT_INDEX::no_type; break;
case ON_COMPONENT_INDEX::brep_vertex: t = ON_COMPONENT_INDEX::brep_vertex; break;
case ... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x6b, %eax
ja 0x6ae0f7
movq -0x10(%rbp), %rax
leaq 0x25693b(%rip), %rcx # 0x9048d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x8(%rbp) # i... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_COMPONENT_INDEX::IsSubDComponentIndex() const | bool ON_COMPONENT_INDEX::IsSubDComponentIndex() const
{
bool rc = false;
switch(m_type)
{
case ON_COMPONENT_INDEX::subd_vertex:
case ON_COMPONENT_INDEX::subd_edge:
case ON_COMPONENT_INDEX::subd_face:
if ( -1 != m_index && 0 != m_index )
{
rc = true;
}
break;
default:
// intention... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movl (%rax), %eax
addl $-0x47, %eax
subl $0x2, %eax
ja 0x6ae1df
jmp 0x6ae1c0
movq -0x18(%rbp), %rcx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl 0x4(%rcx), %eax
je 0x6ae1dd
movq -0x18(%rbp), %rcx
... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_COMPONENT_INDEX::IsSet() const | bool ON_COMPONENT_INDEX::IsSet() const
{
bool rc = false;
switch(m_type)
{
case ON_COMPONENT_INDEX::invalid_type:
rc = false;
break;
case ON_COMPONENT_INDEX::no_type:
rc = false;
break;
case ON_COMPONENT_INDEX::brep_vertex:
case ON_COMPONENT_INDEX::brep_edge:
case ON_COMPONENT_INDEX::b... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x9(%rbp)
movl (%rax), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6b, %eax
ja 0x6aebc5
movq -0x18(%rbp), %rax
leaq 0x25609a(%rip), %rcx # 0x904c38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jm... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_ComponentIndexAndNumber::CompareNumber(ON_ComponentIndexAndNumber const*, ON_ComponentIndexAndNumber const*) | int ON_ComponentIndexAndNumber::CompareNumber(
const ON_ComponentIndexAndNumber* a,
const ON_ComponentIndexAndNumber* b
)
{
if (a == b)
return 0;
if (nullptr == a)
return -1; // nulls sort last
if (nullptr == b)
return -1; // nulls sort last
return ON_CompareDouble(a->m_x, b->m_x);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x6aeea3
movl $0x0, -0x4(%rbp)
jmp 0x6aeedf
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x6aeeb4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6aeedf
xorl %eax, %eax
cmpq -0... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_ObjRefEvaluationParameter::ON_ObjRefEvaluationParameter() | ON_ObjRefEvaluationParameter::ON_ObjRefEvaluationParameter()
: m_t_type(0)
, m_reserved(0)
{
m_t[0] = ON_UNSET_VALUE;
m_t[1] = ON_UNSET_VALUE;
m_t[2] = ON_UNSET_VALUE;
m_t[3] = ON_UNSET_VALUE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
addq $0x28, %rax
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x312500
movq -0x28(%r... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_ObjRef::ON_ObjRef() | ON_ObjRef::ON_ObjRef()
: m_uuid(ON_nil_uuid),
m_geometry(0),
m_parent_geometry(0),
m_geometry_type(ON::unknown_object_type),
m_runtime_sn(0),
m_point(ON_3dPoint::UnsetPoint),
m_osnap_mode(ON::os_none),
m__proxy1(0),
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x3cd535(%rip), %rax # 0xa7c8b0
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x30ac90
movq -0x10(%rbp... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_ObjRef::ON_ObjRef(ON_ObjRef const&) | ON_ObjRef::ON_ObjRef( const ON_ObjRef& src )
: m_uuid(src.m_uuid),
m_geometry(src.m_geometry),
m_parent_geometry(src.m_parent_geometry),
m_component_index(src.m_component_index),
m_geometry_type(src.m_geometry_type),
m_runtime_sn(src.m_runtime_sn),
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rdi)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_ObjRef::operator=(ON_ObjRef const&) | ON_ObjRef& ON_ObjRef::operator=( const ON_ObjRef& src )
{
if ( this != &src )
{
// Remove any reference this ON_ObjRef class
// may currently have.
DecrementProxyReferenceCount();
// copy the values from src
m_uuid = src.m_uuid;
m_geometry = src.m_geometry;
m_parent_geometry = src.m_p... | 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 0x6af8bf
movq -0x18(%rbp), %rdi
callq 0x314370
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rax
movq %rax,... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_ObjRef_IRefID::Read(ON_BinaryArchive&) | bool ON_ObjRef_IRefID::Read( ON_BinaryArchive& archive )
{
Default();
int major_version = 0;
int minor_version = 0;
bool rc = archive.BeginRead3dmChunk(
TCODE_ANONYMOUS_CHUNK,
&major_version,
&minor_version );
if ( !rc )
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x321e10
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_objref.cpp |
ON_ObjRef::ProxyObject(int) const | const ON_Object* ON_ObjRef::ProxyObject(int proxy_object_index) const
{
return ( (1 == proxy_object_index)
? m__proxy1
: ((2==proxy_object_index) ? m__proxy2 : 0)
);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jne 0x6b0cfe
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6b0d29
movl $0x2, %eax
cmpl -0xc(%rbp), %eax
jne 0x6b0d19
movq -0x18(%rbp), %ra... | /mcneel[P]opennurbs/opennurbs_objref.cpp |
ON_SimpleArray<ON_ObjRef_IRefID>::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 0x6b1132
cmpl $0x0, -0x10(%rbp)
jl 0x6b1132
cmpl $0x0, -0xc(%rbp)
jl 0x6b1132
movl -0x10(%rbp), %eax
cmpl -0xc(%rb... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_OffsetSurface::operator=(ON_OffsetSurface const&) | ON_OffsetSurface& ON_OffsetSurface::operator=(const ON_OffsetSurface& src)
{
if ( this != &src )
{
if ( 0 != m__pSrf && this != m__pSrf )
delete m__pSrf;
m__pSrf = 0;
if ( 0 != src.m__pSrf )
{
m__pSrf = src.ON_SurfaceProxy::DuplicateSurface();
SetProxySurface(m__pSrf);
}
el... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x6b13ec
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x6b1376
movq -0x18(%rbp), %rax
cmpq 0x20(%rax), %rax
je 0x6b1376
movq -0x18(%rbp), %ra... | /mcneel[P]opennurbs/opennurbs_offsetsurface.cpp |
ON_OffsetSurface::ON_OffsetSurface(ON_OffsetSurface const&) | ON_OffsetSurface::ON_OffsetSurface( const ON_OffsetSurface& src)
: ON_SurfaceProxy(src),
m__pSrf(0),
m_offset_function(src.m_offset_function)
{
if ( 0 != src.m__pSrf )
{
m__pSrf = src.ON_SurfaceProxy::DuplicateSurface();
SetProxySurface(m__pSrf);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x303360
movq -0x30(%rbp), %rdi
movq 0x3cb2cc(%rip), %rax # 0xa7c9a8
addq $0x10, %rax
movq %rax, (%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, ... | /mcneel[P]opennurbs/opennurbs_offsetsurface.cpp |
ON_OffsetSurface::Evaluate(double, double, int, int, double*, int, int*) const | bool ON_OffsetSurface::Evaluate(
double s, double t,
int der_count,
int v_stride,
double* v,
int side,
int* hint
) const
{
int vv_stride = v_stride;
double* vv = v;
ON_3dVector srf_value[6];//, normal_value[3];
if ( der_count < 2 )
{
vv = &srf_value[0].x;
... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movl -0x20(%rbp), ... | /mcneel[P]opennurbs/opennurbs_offsetsurface.cpp |
ON_BumpFunction::Evaluate(double, double, int, double*) const | void ON_BumpFunction::Evaluate(double s, double t, int der_count, double* value) const
{
double tmp[20];
double* xvalue;
double* yvalue;
xvalue = ( der_count > 9 )
? ((double*)onmalloc((der_count+1)*2*sizeof(xvalue[0])))
: &tmp[0];
yvalue = xvalue + (der_count+1);
double x = s-m_x0;
con... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
cmpl $0x9, -0x1c(%rbp)
jle 0x6b257e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
shll %eax
m... | /mcneel[P]opennurbs/opennurbs_offsetsurface.cpp |
ON_OffsetSurfaceFunction::PointAt(double, double) const | ON_3dPoint ON_OffsetSurfaceFunction::PointAt(
double s,
double t
) const
{
//double d = 0.0;
ON_3dPoint P(ON_3dPoint::NanPoint);
ON_3dVector N(ON_3dVector::NanVector);
if ( 0 != m_srf )
{
if ( m_srf->EvNormal(s,t,P,N) )
{
P = P + DistanceAt(s,t)*N;
}
}
return P;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq 0x3ca65d(%rip), %rax # 0xa7e260
movq (%rax), %rdx
movq %rdx, (%rdi)
movq 0x8(%rax), %rdx
... | /mcneel[P]opennurbs/opennurbs_offsetsurface.cpp |
ON_OffsetSurfaceFunction::SetDistance(int, double) | bool ON_OffsetSurfaceFunction::SetDistance( int index, double distance)
{
int count = m_offset_value.Count();
if( index < 0 || index > count-1)
return false;
m_offset_value[index].m_distance = distance;
m_bValid = false;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x30, %rdi
callq 0x3371f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6b418b
movl -0x14(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %e... | /mcneel[P]opennurbs/opennurbs_offsetsurface.cpp |
ON_OffsetSurfaceFunction::SetPoint(int, double, double) | bool ON_OffsetSurfaceFunction::SetPoint( int index, double s, double t)
{
int count = m_offset_value.Count();
if( index < 0 || index > count-1)
return false;
m_offset_value[index].m_s = s;
m_offset_value[index].m_t = t;
m_bValid = false;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x30, %rdi
callq 0x3371f0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6b4210
movl -0x14(%rbp), %eax
movl -0x2c(%rbp), %ec... | /mcneel[P]opennurbs/opennurbs_offsetsurface.cpp |
ON_OffsetSurfaceFunction::ON_OffsetSurfaceFunction(ON_OffsetSurfaceFunction const&) | class ON_CLASS ON_OffsetSurfaceFunction
{
public:
ON_OffsetSurfaceFunction();
~ON_OffsetSurfaceFunction();
/*
Description:
Sets base surface for the offset function.
Parameters:
srf - [in] pointer to the base surface.
This surface must remain valid while
the ON_OffsetSur... | 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), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x1c(%rax), %xmm2
movups %xmm2, 0x1c(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x30, %rdi
movq... | /mcneel[P]opennurbs/opennurbs_offsetsurface.h |
ON_SimpleArray<ON_BumpFunction>::operator=(ON_SimpleArray<ON_BumpFunction> const&) | ON_SimpleArray<T>& ON_SimpleArray<T>::operator=( const ON_SimpleArray<T>& src )
{
if( this != &src ) {
if ( src.m_count <= 0 ) {
m_count = 0;
}
else {
if ( m_capacity < src.m_count ) {
SetCapacity( src.m_count );
}
if ( m_a ) {
m_count = src.m_count;
memcpy(... | 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 0x6b4e3c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jg 0x6b4de5
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x6b4e3a
movq -0x18(%rbp), %rax
movl 0x14(%ra... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_LocalZero1::BracketSpan(double, double, double, double) | bool
ON_LocalZero1::BracketSpan( double s0, double f0, double s1, double f1 )
{
int i0, i1, i;
double fm, fp;
bool rc = true;
if ( m_k && m_k_count >= 3 ) {
i0 = ON_SearchMonotoneArray(m_k,m_k_count,s0);
if ( i0 < 0 )
i0 = 0;
i1 = ON_SearchMonotoneArray(m_k,m_k_count,s1);
if ( i1 >= m_k_co... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x1, -0x49(%rbp)
cmpq $0x0, 0x28(%rax)
je 0x6b6719
movq -0x58(%rbp), %rax
cmpl $0x3, 0x30(%rax)
jl 0x6b... | /mcneel[P]opennurbs/opennurbs_optimize.cpp |
ON_ParseAngleExpression(wchar_t const*, int, ON_ParseSettings, ON::AngleUnitSystem, double*, ON_ParseSettings*, ON::AngleUnitSystem*) | int ON_ParseAngleExpression(
const wchar_t* str,
int str_count,
ON_ParseSettings parse_settings,
const ON::AngleUnitSystem angle_value_unit_system,
double* angle_value,
ON_ParseSettings* parse_results,
ON::AngleUnitSystem* str_angle_unit_system
)
{
ON::AngleUnitSystem parsed_angle_us = ON::AngleUnitS... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %dl, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movsd 0x21c547(%rip), %xmm0 # 0x8d3768
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%... | /mcneel[P]opennurbs/opennurbs_parse_angle.cpp |
ON_ParseLengthExpression(wchar_t const*, int, ON_ParseSettings, ON::LengthUnitSystem, double*, ON_ParseSettings*, ON::LengthUnitSystem*) | int ON_ParseLengthExpression(
const wchar_t* str,
int str_count,
ON_ParseSettings parse_settings,
ON::LengthUnitSystem length_value_unit_system,
double* length_value,
ON_ParseSettings* parse_results,
ON::LengthUnitSystem* str_length_unit_system
)
{
ON::LengthUnitSystem us = ON::LengthUnitSystem::None... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dl, %al
leaq 0x10(%rbp), %rdx
movq %rdx, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movb $0xb, %al
cmpb -0x15(%rbp), %al
jne 0x6b753c
xorl %eax... | /mcneel[P]opennurbs/opennurbs_parse_length.cpp |
ON_ParseLengthExpression(wchar_t const*, int, ON_ParseSettings, double*, ON_ParseSettings*, ON::LengthUnitSystem*) | int ON_ParseLengthExpression(
const wchar_t* str,
int str_count,
ON_ParseSettings parse_settings,
double* length_value,
ON_ParseSettings* parse_results,
ON::LengthUnitSystem* str_length_unit_system
)
{
double x = ON_UNSET_VALUE;
ON::LengthUnitSystem length_us = ON::LengthUnitSystem::None;
const ON_... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movsd 0x219abe(%rip), %xmm0 # 0x8d3768
movsd %xmm0, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq (%rax), %rcx
movq %r... | /mcneel[P]opennurbs/opennurbs_parse_number.cpp |
ON_ParseAngleExpression(wchar_t const*, int, ON_ParseSettings, double*, ON_ParseSettings*, ON::AngleUnitSystem*) | int ON_ParseAngleExpression(
const wchar_t* str,
int str_count,
ON_ParseSettings parse_settings,
double* angle_value,
ON_ParseSettings* parse_results,
ON::AngleUnitSystem* str_angle_unit_system
)
{
double x = ON_UNSET_VALUE;
ON::AngleUnitSystem angle_us = ON::AngleUnitSystem::None;
ON_ParseSettings... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
leaq 0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movsd 0x2191f7(%rip), %xmm0 # 0x8d3768
movsd %xmm0, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
m... | /mcneel[P]opennurbs/opennurbs_parse_number.cpp |
ON_ParseSettings::SetContextAngleUnitSystem(ON::AngleUnitSystem) | void ON_ParseSettings::SetContextAngleUnitSystem(
ON::AngleUnitSystem context_angle_unit_system
)
{
for (;;)
{
if (ON::AngleUnitSystem::None == context_angle_unit_system || ON::AngleUnitSystem::Unset == context_angle_unit_system)
break;
const unsigned int angle_unit_system_as_unsigned = static_cas... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpb -0x9(%rbp), %al
je 0x6bd428
movb $-0x1, %al
cmpb -0x9(%rbp), %al
jne 0x6bd42a
jmp 0x6bd461
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0xff, -0... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_ParseSettings::Compare(ON_ParseSettings const*, ON_ParseSettings const*) | const int ON_ParseSettings::Compare(
const ON_ParseSettings* a,
const ON_ParseSettings* b
)
{
size_t i;
if ( 0 == a || 0 == b )
{
if ( 0 != b )
return -1;
if ( 0 != a )
return 1;
return 0;
}
for ( i = 0; i < sizeof(a->m_true_default_bits)/sizeof(a->m_true_default_bits[0]); i+... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x6bd5ac
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x6bd5e0
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x6bd5c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6bd76a
xorl %eax, %eax
cmpq -0x10(%rbp)... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
DoubleNumberSettingsHelper() | static ON_ParseSettings DoubleNumberSettingsHelper()
{
ON_ParseSettings double_number_settings(ON_ParseSettings::IntegerNumberSettings);
// do not enable parsing of leading white space here
double_number_settings.SetParseSignificandDecimalPoint(true);
double_number_settings.SetParseSignificandFractionalPart(tru... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
movq 0x3c01be(%rip), %rax # 0xa7dec8
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rdi)
movl $0x1... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_ParseSettings::IsLeadingWhiteSpace(unsigned int) const | bool ON_ParseSettings::IsLeadingWhiteSpace(ON__UINT32 c) const
{
if (IsInteriorWhiteSpace(c))
return true;
switch(c)
{
case 0x000A: // line feed
if ( ParseLineFeedAsLeadingWhiteSpace() )
return true;
break;
case 0x000B: // vertical tab
if ( ParseVerticalTabAsLeadingWhiteSpace() )
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
callq 0x3052b0
testb $0x1, %al
jne 0x6bfa65
jmp 0x6bfa6e
movb $0x1, -0x1(%rbp)
jmp 0x6bfaf3
movl -0x14(%rbp), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_ParseSettings::IsUnaryMinus(unsigned int) const | bool ON_ParseSettings::IsUnaryMinus(ON__UINT32 c) const
{
switch(c)
{
case 0x002D: // hyphen-minus
if ( ON_ParseNumberSettingsBitTrueDefault(bitdex_true_default::parse_hyphen_minus_as_unary_minus) )
return true;
break;
case 0x02D7: // modifier letter minus sign
if ( ON_ParseNumberSettingsBitT... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x2d, %eax
je 0x6bfce3
jmp 0x6bfcb0
movl -0x18(%rbp), %eax
subl $0x2d7, %eax # imm = 0x2D7
je 0x6bfcfe
jmp 0x6bfcbc
movl -0x18(%rbp), %eax... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_ParseSettings::IsDecimalExponentSymbol(unsigned int) const | bool ON_ParseSettings::IsDecimalExponentSymbol(ON__UINT32 c) const
{
switch(c)
{
case 'e': // lower case e
case 'E': // capital E
case 0x23E8: // decimal exponent symbol
return true;
break;
case 'D': // capital D
case 'd': // lower case d
return ParseDAsExponentInScientificENotation();
br... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x44, %eax
je 0x6c0054
jmp 0x6c0024
movl -0x18(%rbp), %eax
subl $0x45, %eax
je 0x6c004e
jmp 0x6c002e
movl -0x18(%rbp), %eax
subl $0x... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_ParseSettings::IsMultiplicationSymbol(unsigned int) const | bool ON_ParseSettings::IsMultiplicationSymbol(ON__UINT32 c) const
{
switch(c)
{
case '*':
case 0x00D7: // unicode multiply by symbol
return true;
break;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x2a, %eax
je 0x6c00e4
jmp 0x6c00d8
movl -0x18(%rbp), %eax
subl $0xd7, %eax
jne 0x6c00ea
jmp 0x6c00e4
movb $0x1, -0x1(%rbp)
jmp 0x6c00ee
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_ParseSettings::IsDivisionSymbol(unsigned int) const | bool ON_ParseSettings::IsDivisionSymbol(ON__UINT32 c) const
{
switch(c)
{
case '/':
case 0x00F7: // unicode divide by symbol
return true;
break;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x2f, %eax
je 0x6c0124
jmp 0x6c0118
movl -0x18(%rbp), %eax
subl $0xf7, %eax
jne 0x6c012a
jmp 0x6c0124
movb $0x1, -0x1(%rbp)
jmp 0x6c012e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_ParseSettings::IsSubtractionSymbol(unsigned int) const | bool ON_ParseSettings::IsSubtractionSymbol(ON__UINT32 c) const
{
switch(c)
{
case '-': // unicode hyphen minus
case 0x2212: // unicode minus sign
return true;
break;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x2d, %eax
je 0x6c0194
jmp 0x6c0188
movl -0x18(%rbp), %eax
subl $0x2212, %eax # imm = 0x2212
jne 0x6c019a
jmp 0x6c0194
movb $0x1, -0x1(%rbp)
jmp 0x6c019e
movb $0x0, -0x1(%rbp)
movb -0x1... | /mcneel[P]opennurbs/opennurbs_parse_settings.cpp |
ON_AerialPhotoImage::ON_AerialPhotoImage() | ON_AerialPhotoImage::ON_AerialPhotoImage()
: m_id(ON_nil_uuid)
, m_image_width_pixels(0)
, m_image_height_pixels(0)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x3390e0
movq -0x28(%rbp), %rdi
movq 0x3bc3d5(%rip), %rax # 0xa7c8b0
movups (%rax), %xmm0
movups %xmm0, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, -0x20(%rbp)
callq 0... | /mcneel[P]opennurbs/opennurbs_photogrammetry.cpp |
ON_AerialPhotoImageFrustum::Unset() | void ON_AerialPhotoImageFrustum::Unset()
{
m_height = ON_UNSET_VALUE;
m_corners[0] = ON_2dPoint::UnsetPoint;
m_corners[1] = ON_2dPoint::UnsetPoint;
m_corners[2] = ON_2dPoint::UnsetPoint;
m_corners[3] = ON_2dPoint::UnsetPoint;
m_unit_system = ON_UnitSystem::None;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movsd 0x213120(%rip), %xmm0 # 0x8d3768
movsd %xmm0, 0x18(%rdi)
movq 0x3bd824(%rip), %rax # 0xa7de78
movq (%rax), %rcx
movq %rcx, 0x20(%rdi)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rdi)
movq 0x3bd80e(%rip), %rax # 0xa7de78
movq... | /mcneel[P]opennurbs/opennurbs_photogrammetry.cpp |
ON_AerialPhotoCameraPosition::UnsetOrientation() | void ON_AerialPhotoCameraPosition::UnsetOrientation()
{
m_status &= 0xFD; // clear bit 2
m_orientation_angles_radians.Set(ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE);
m_orientation_angles_degrees.Set(ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE);
m_orientation_rotation = ON_Xform::Zero4x4;
m_orientation_... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movzbl (%rdi), %eax
andl $0xfd, %eax
movb %al, (%rdi)
addq $0x50, %rdi
movsd 0x21266e(%rip), %xmm2 # 0x8d3768
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x3155e0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
mo... | /mcneel[P]opennurbs/opennurbs_photogrammetry.cpp |
ON_AerialPhotoCameraPosition::SetOrientationAnglesRadians(double, double, double) | bool ON_AerialPhotoCameraPosition::SetOrientationAnglesRadians(
double omega_radians,
double phi_radians,
double kappa_radians
)
{
bool rc = false;
if ( ON_IsValid(omega_radians) && ON_IsValid(phi_radians) && ON_IsValid(kappa_radians) )
{
m_orientation_angles_radians.Set(omega_radians,phi_r... | pushq %rbp
movq %rsp, %rbp
subq $0x860, %rsp # imm = 0x860
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x828(%rbp)
movb $0x0, -0x21(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x326490
testb $0x1, %al
jne 0x6c2190
jmp 0x6c2ca0
mo... | /mcneel[P]opennurbs/opennurbs_photogrammetry.cpp |
ON_AerialPhotoImage::GetViewProjection(ON_BoundingBox, ON_Viewport&) const | bool ON_AerialPhotoImage::GetViewProjection(
ON_BoundingBox target_bbox,
ON_Viewport& viewport
) const
{
viewport = ON_Viewport::DefaultTopViewYUp;
if ( !this->ImageSizeIsSet() )
return false;
const int image_width_pixels = m_image_width_pixels;
const int image_height_pixels = m_image_height_pixe... | pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp # imm = 0x500
leaq 0x10(%rbp), %rax
movq %rax, -0x4a0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x498(%rbp)
movq -0x18(%rbp), %rdi
movq 0x3b96dc(%rip), %rsi # 0xa7c3d0
callq 0x330fe0
movq -0x498(%rbp), %rdi
callq 0x3... | /mcneel[P]opennurbs/opennurbs_photogrammetry.cpp |
ON_Plane::CreateFromFrame(ON_3dPoint const&, ON_3dVector const&, ON_3dVector const&) | bool ON_Plane::CreateFromFrame(
const ON_3dPoint& P, // point on the plane
const ON_3dVector& X, // non-zero vector in plane
const ON_3dVector& Y // another non-zero vector in the plane
)
{
const ON_3dPoint localP(P);
const ON_3dVector localX(X);
const ON_3dVector localY(Y);
origin = localP;... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax,... | /mcneel[P]opennurbs/opennurbs_plane.cpp |
ON_Plane::ClosestPointTo(ON_3dPoint, double*, double*) const | bool ON_Plane::ClosestPointTo( ON_3dPoint p, double* s, double* t ) const
{
const ON_3dVector v = p - origin;
if ( s )
*s = v*xaxis;
if ( t )
*t = v*yaxis;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, %rax
leaq 0x10(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x32c3c0
cmpq $0x0, -0x10(%rbp)
je 0x6c484c
movq -0x38(%rbp), %rsi
addq $0x18, %rsi
leaq -0x30(%... | /mcneel[P]opennurbs/opennurbs_plane.cpp |
ON_PlaneSurface::operator=(ON_PlaneSurface const&) | ON_PlaneSurface& ON_PlaneSurface::operator=( const ON_PlaneSurface& src )
{
if ( this != &src ) {
ON_Surface::operator=(src);
m_plane = src.m_plane;
m_domain[0] = src.m_domain[0];
m_domain[1] = src.m_domain[1];
m_extents[0] = src.m_extents[0];
m_extents[1] = src.m_extents[1];
}
return *thi... | 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 0x6c5ddd
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x323790
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
movl $0x80... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_PlaneSurface::Evaluate(double, double, int, int, double*, int, int*) const | bool
ON_PlaneSurface::Evaluate( // returns false if unable to evaluate
double s, double t, // evaluation parameters
int der_count, // number of derivatives (>=0)
int v_stride, // v[] array stride (>=Dimension())
double* v, // v[] array of length stride*(ndir+1)
int side, ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
movsd 0x20bc85(%rip), %xmm0 # 0x8d3000
movs... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_PlaneSurface::Trim(int, ON_Interval const&) | bool ON_PlaneSurface::Trim(
int dir,
const ON_Interval& domain
)
{
if ( dir < 0 || dir > 1 )
return false;
ON_Interval current_domain = Domain(dir);
if ( current_domain[0] == ON_UNSET_VALUE && current_domain[1] == ON_UNSET_VALUE )
current_domain = domain;
ON_Interval trim_domain, tr... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6c78fa
cmpl $0x1, -0x14(%rbp)
jle 0x6c7903
movb $0x0, -0x1(%rbp)
jmp 0x6c7b6e
movq -0x78(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rd... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_PlaneSurface::GetNurbForm(ON_NurbsSurface&, double) const | int ON_PlaneSurface::GetNurbForm( // returns 0: unable to create NURBS representation
// with desired accuracy.
// 1: success - returned NURBS parameterization
// matches the surface's to the desired accuracy
// ... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
callq *0x30(%rax)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x6c8371
movq -0xa0(%rbp), %... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_PlaneSurface::CreatePseudoInfinitePlane(ON_Plane const&, int, ON_3dPoint const*, double) | bool ON_PlaneSurface::CreatePseudoInfinitePlane(
const ON_Plane& plane,
int point_count,
const ON_3dPoint* point_list,
double padding
)
{
if ( !plane.IsValid() )
return false;
if ( point_count < 1 )
return false;
if ( 0 == point_list )
return false;
if ( !ON_... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32e8e0
testb $0x1, %al
jne 0x6c8910
movb $0x0, -0x1(%rbp)
jmp 0x6c8d17
cmpl $0x1, ... | /mcneel[P]opennurbs/opennurbs_planesurface.cpp |
ON_PlaneSurface::CreatePlaneThroughBox(ON_Plane const&, ON_BoundingBox const&, double) | bool ON_PlaneSurface::CreatePlaneThroughBox(
const ON_Plane& plane,
const ON_BoundingBox& bbox,
double padding
)
{
if (!plane.IsValid() || !bbox.IsValid())
return false;
ON_Interval uext(ON_DBL_PINF, ON_DBL_NINF);
ON_Interval vext(ON_DBL_PINF, ON_DBL_NINF);
double t, u, v;
for (int i = 0; i < 12; i... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32e8e0
testb $0x1, %al
jne 0x6c8d66
jmp 0x6c8d73
movq -0x20(%rbp), %rdi
callq ... | /mcneel[P]opennurbs/opennurbs_planesurface.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.