name string | code string | asm string | file string |
|---|---|---|---|
ON_Buffer::WriteToBinaryArchive(ON_BinaryArchive&) const | bool ON_Buffer::WriteToBinaryArchive( ON_BinaryArchive& archive ) const
{
// The ON_Buffer::CRC32() calculation will call ON_ERROR if the segment list
// is not perfect. The code below that goes through the segments
// checks for errors so that crashes are avoided, but does not make
// additional calls to ON_E... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
callq 0x303400
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x28100, %esi # imm = 0x28100
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x305e30
testb $0x1, %al... | /mcneel[P]opennurbs/opennurbs_embedded_file.cpp |
ON_Buffer::ReadFromBinaryArchive(ON_BinaryArchive&) | bool ON_Buffer::ReadFromBinaryArchive( ON_BinaryArchive& archive )
{
Destroy();
int major_version = 0;
int minor_version = 0;
if ( !archive.BeginRead3dmChunk(TCODE_OPENNURBS_BUFFER,&major_version,&minor_version) )
return false;
ON_3DM_BIG_CHUNK c0;
memset(&c0,0,sizeof(c0));
archive.GetCurrentChunk... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3101a0
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x28100, %esi # imm = 0x28100
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x3... | /mcneel[P]opennurbs/opennurbs_embedded_file.cpp |
ON_Buffer::Compress(ON_Buffer&) const | bool ON_Buffer::Compress( ON_Buffer& compressed_buffer ) const
{
bool rc = false;
ON_CompressStream compressor;
ON_Buffer* out = ( this == &compressed_buffer ) ? new ON_Buffer() : &compressed_buffer;
out->Destroy();
for (;;)
{
ON__UINT64 uncompressed_size = Size();
if ( uncompressed_size <= 0 )
... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x30bd50
movq -0xa8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, -0x79(%rbp)
cmpq %rcx, %rax
jne 0x4ebb38
m... | /mcneel[P]opennurbs/opennurbs_embedded_file.cpp |
ON_Buffer::Uncompress(ON_Buffer&) const | bool ON_Buffer::Uncompress( ON_Buffer& uncompressed_buffer ) const
{
bool rc = false;
ON_UncompressStream uncompressor;
ON_Buffer* out = ( this == &uncompressed_buffer ) ? new ON_Buffer() : &uncompressed_buffer;
out->Destroy();
for (;;)
{
ON__UINT64 compressed_size = Size();
if ( compressed_size <... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31e3c0
movq -0xa8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, -0x79(%rbp)
cmpq %rcx, %rax
jne 0x4ec0a8
m... | /mcneel[P]opennurbs/opennurbs_embedded_file.cpp |
ON_MathError | void ON_MathError(
const char* sModuleName,
const char* sErrorType,
const char* sFunctionName
)
{
ON_MATH_ERROR_COUNT++;
if ( 0 == sModuleName)
sModuleName = "";
if ( 0 == sErrorType )
sErrorType = "";
if ( 0 == sFunctionName )
sFunctionName = "";
if ( 0 != sModu... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl 0x5b8556(%rip), %eax # 0xaa52a0
addl $0x1, %eax
movl %eax, 0x5b854d(%rip) # 0xaa52a0
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x4ecd66
leaq 0x4275df(%rip), %rax # 0x914341
movq %rax, -0x8(%rbp)... | /mcneel[P]opennurbs/opennurbs_error.cpp |
ON_Error | void ON_VARGS_FUNC_CDECL ON_Error(
const char* sFileName,
int line_number,
const char* sFormat,
...
)
{
ON_IncrementErrorCount();
const bool bPrintErrorMessage = ON_Internal_PrintErrorMessage();
if ( bPrintErrorMessage || ON_Internal_LogError() )
{
ON_String description;
if (sFormat && sFormat... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
testb %al, %al
je 0x4ed067
movaps %xmm0, -0x170(%rbp)
movaps %xmm1, -0x160(%rbp)
movaps %xmm2, -0x150(%rbp)
movaps %xmm3, -0x140(%rbp)
movaps %xmm4, -0x130(%rbp)
movaps %xmm5, -0x120(%rbp)
movaps %xmm6, -0x110(%rbp)
movaps %xmm7, -0x100(%rbp)
movq %r... | /mcneel[P]opennurbs/opennurbs_error.cpp |
ON_ErrorEvent::ToString() const | const ON_String ON_ErrorEvent::ToString() const
{
const char* function_name = FunctionName();
const char* description = Description();
if (0 != function_name[0])
{
return ON_String::FormatToString(
"%s.%u %s(): %s \"%s\"",
FileName(),
LineNumber(),
function_name,
ON_ErrorEven... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x337a50
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x31ace0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
m... | /mcneel[P]opennurbs/opennurbs_error.cpp |
ON_ErrorLog::Dump(ON_TextLog&) const | void ON_ErrorLog::Dump(
class ON_TextLog& text_log
) const
{
const unsigned int count = Count();
text_log.Print("Error log: %u events\n", count);
ON_TextLogIndent indent1(text_log);
for (unsigned int i = 0; i < count; i++)
{
m_events[i].Dump(text_log);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x323fd0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x3f9cfb(%rip), %rsi # 0x8e81e9
movb $0x0, %al
callq 0x3188f0
movq -0x10(%rbp), %rsi
leaq -0x2... | /mcneel[P]opennurbs/opennurbs_error.cpp |
ON_ErrorMessage | void ON_ErrorMessage(
int message_type, // 0=warning - serious problem that code is designed to handle
// 1=error - serious problem code will attempt to handle
// The thing causing the error is a bug that must
// b... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4ee70d
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4ee70d
jmp 0x4ee70d
popq %rbp
retq
nop
| /mcneel[P]opennurbs/opennurbs_error_message.cpp |
ON_EvaluateBernsteinBasis(int, int, double) | double ON_EvaluateBernsteinBasis(int degree, int i, double t)
/*****************************************************************************
Evaluate Bernstein basis polynomial
INPUT:
degree
If degree < 0, then 0.0 is returned.
i
If i < 0 or i > degree, then 0.0 is returned.
t
The formula for the Be... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4ee73a
cmpl $0x0, -0x10(%rbp)
jl 0x4ee73a
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x4ee747
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4eeb23
movl -0xc(%rbp), %eax
m... | /mcneel[P]opennurbs/opennurbs_evaluate_nurbs.cpp |
ON_EvaluatedeCasteljau(int, int, int, int, double*, double) | void ON_EvaluatedeCasteljau(int dim, int order, int side, int cv_stride, double* cv, double t)
/*****************************************************************************
Evaluate a Bezier using the de Casteljau algorithm
INPUT:
dim ( >= 1)
order ( >= 2)
side <= 0 return left side of bezier in cv array... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4eeb6b
jp 0x4eeb6b
jmp 0x4eeb80
movsd -0x20(%rbp), %xmm0
movsd 0x3e4488(%rip), %xmm1 ... | /mcneel[P]opennurbs/opennurbs_evaluate_nurbs.cpp |
ON_SimpleArray<ON_InstanceRef 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 0x508022
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x50803d
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_InstanceRef const*>::Move(int, int, int) | void ON_SimpleArray<T>::Move( int dest_i, int src_i, int ele_cnt )
{
// private function for moving blocks of array memory
// caller is responsible for updating m_count.
if ( ele_cnt <= 0 || src_i < 0 || dest_i < 0 || src_i == dest_i ||
src_i + ele_cnt > m_count || dest_i > m_count )
return;
int ca... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x508272
cmpl $0x0, -0x10(%rbp)
jl 0x508272
cmpl $0x0, -0xc(%rbp)
jl 0x508272
movl -0x10(%rbp), %eax
cmpl -0xc(%rb... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<unsigned long>::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 0x508c92
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x508cad
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<unsigned char*>::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 0x508eb2
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x508ecd
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_String::SplitPath(char const*, ON_String*, ON_String*, ON_String*, ON_String*) | void ON_String::SplitPath(
const char* path,
ON_String* drive,
ON_String* dir,
ON_String* fname,
ON_String* ext
)
{
ON_FileSystemPath::SplitPath(
path,
drive,
dir,
fname,
ext
);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x32c6d0
addq $0x30, %rsp
popq %rbp
retq
nop... | /mcneel[P]opennurbs/opennurbs_file_utilities.cpp |
ON_FileSystemPath::SplitPath(wchar_t const*, ON_wString*, ON_wString*, ON_wString*, ON_wString*) | void ON_FileSystemPath::SplitPath(
const wchar_t* path,
ON_wString* drive,
ON_wString* dir,
ON_wString* file_name_stem,
ON_wString* ext
)
{
const wchar_t* dr = 0;
const wchar_t* d = 0;
const wchar_t* f = 0;
const wchar_t* e = 0;
// Use local path in case drive, dir, file_name_stem or ext are bei... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
cal... | /mcneel[P]opennurbs/opennurbs_file_utilities.cpp |
ON_OBSOLETE_V5_TextExtra::TextExtension(ON_OBSOLETE_V5_TextObject*, bool) | ON_OBSOLETE_V5_TextExtra* ON_OBSOLETE_V5_TextExtra::TextExtension(ON_OBSOLETE_V5_TextObject* pText, bool bCreate)
{
ON_OBSOLETE_V5_TextExtra* pExtra = 0;
if(pText)
{
pExtra = ON_OBSOLETE_V5_TextExtra::Cast(pText->GetUserData(ON_CLASS_ID(ON_OBSOLETE_V5_TextExtra)));
if(pExtra == 0 && bCreate)
{
p... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x565fcc
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x5185ba(%rip), %rdi # 0xa7e4d0
callq 0x330230
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_TextExtra::Write(ON_BinaryArchive&) const | bool ON_OBSOLETE_V5_TextExtra::Write(ON_BinaryArchive& archive) const
{
bool rc = archive.BeginWrite3dmChunk(TCODE_ANONYMOUS_CHUNK,1,0);
if(rc) rc = archive.WriteUuid(m_parent_uuid);
if(rc) rc = archive.WriteBool(m_bDrawMask);
if(rc) rc = archive.WriteInt(m_color_source);
if(rc) rc = archive.WriteColor(m_mas... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40008000, %esi # imm = 0x40008000
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x305e30
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x56... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_TextExtra::Read(ON_BinaryArchive&) | bool ON_OBSOLETE_V5_TextExtra::Read(ON_BinaryArchive& archive)
{
int major_version = 1;
int minor_version = 0;
bool rc = archive.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version);
if(!rc)
return false;
if(major_version != 1)
return false;
if(rc) rc = archive.ReadUuid(m_parent_u... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x40008000, %esi # imm = 0x40008000
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x301180
andb $... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_DimExtra::Cast(ON_Object*) | ON_OBSOLETE_V5_DimExtra::ON_OBSOLETE_V5_DimExtra()
{
m_userdata_uuid = ON_CLASS_ID(ON_OBSOLETE_V5_DimExtra);
m_application_uuid = ON_opennurbs5_id; // opennurbs.dll reads/writes this userdata
// The id must be the version 5 id because
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5664b3
movq -0x8(%rbp), %rdi
movq 0x516f1a(%rip), %rsi # 0xa7d3b8
callq 0x32e120
testb $0x1, %al
jne 0x5664a9
jmp 0x5664b3
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5664bb
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp ... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_DimExtra::ClassId() const | ON_OBSOLETE_V5_DimExtra::ON_OBSOLETE_V5_DimExtra()
{
m_userdata_uuid = ON_CLASS_ID(ON_OBSOLETE_V5_DimExtra);
m_application_uuid = ON_opennurbs5_id; // opennurbs.dll reads/writes this userdata
// The id must be the version 5 id because
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0x516e89(%rip), %rax # 0xa7d3b8
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_DimExtra::Internal_DeepCopy() const | ON_OBSOLETE_V5_DimExtra::ON_OBSOLETE_V5_DimExtra()
{
m_userdata_uuid = ON_CLASS_ID(ON_OBSOLETE_V5_DimExtra);
m_application_uuid = ON_opennurbs5_id; // opennurbs.dll reads/writes this userdata
// The id must be the version 5 id because
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x118, %edi # imm = 0x118
callq 0x3003f0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x2fadf0
jmp 0x5665f3
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq ... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
AnnotationExtension(ON_OBSOLETE_V5_Annotation*, bool) | static ON_OBSOLETE_V5_DimExtra* AnnotationExtension(ON_OBSOLETE_V5_Annotation* pDim, bool bCreate)
{
ON_OBSOLETE_V5_DimExtra* pExtra = 0;
if(pDim)
{
pExtra = ON_OBSOLETE_V5_DimExtra::Cast(pDim->GetUserData(ON_CLASS_ID(ON_OBSOLETE_V5_DimExtra)));
if(pExtra == 0 && bCreate)
{
pExtra = new ON_OBSOL... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5668cc
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x516ba2(%rip), %rdi # 0xa7d3b8
callq 0x330230
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_Annotation::Destroy() | void ON_OBSOLETE_V5_Annotation::Destroy()
{
m_v5_3dm_archive_dimstyle_index = -1;
// 10-27-03 LW memory leak prevention
m_points.Empty();
SetTextValue(0);
SetTextFormula(0);
m_type = ON_INTERNAL_OBSOLETE::V5_eAnnotationType::dtNothing;
m_plane = ON_xy_plane;
m_userpositionedtext = false;
m_justificat... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0xffffffff, 0xcc(%rdi) # imm = 0xFFFFFFFF
addq $0x98, %rdi
callq 0x302260
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3196a0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
call... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_DimRadial::CreateFromV2RadialDimension(ON_OBSOLETE_V2_DimRadial const&, ON_3dmAnnotationContext const*, ON_OBSOLETE_V5_DimRadial*) | ON_OBSOLETE_V5_DimRadial* ON_OBSOLETE_V5_DimRadial::CreateFromV2RadialDimension(
const class ON_OBSOLETE_V2_DimRadial& V2_radial_dimension,
const class ON_3dmAnnotationContext* annotation_context,
ON_OBSOLETE_V5_DimRadial* destination
)
{
ON_OBSOLETE_V5_DimRadial* V5_radial_dimension
= (nullptr != destinati... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x56826d
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x56829a
movl $0xe0, %edi
callq 0x3003f0
movq %rax, %rdi
movq %rdi, ... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_OBSOLETE_V5_Annotation::IsValid(ON_TextLog*) const | bool ON_OBSOLETE_V5_Annotation::IsValid( ON_TextLog* text_log ) const
{
if ( !m_plane.IsValid() )
{
if ( text_log )
{
text_log->Print("ON_OBSOLETE_V5_Annotation - m_plane is not valid\n");
}
return false;
}
const int points_count = m_points.Count();
int i;
for ( i = 0; i < points_cou... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
callq 0x32e8e0
testb $0x1, %al
jne 0x568fa7
cmpq $0x0, -0x18(%rbp)
je 0x568f9e
movq -0x18(%rbp), %rdi
leaq 0x38f674(%rip), %rsi # 0x8f860b
movb $0x0, %al
callq 0x31... | /mcneel[P]opennurbs/opennurbs_internal_V2_annotation.cpp |
ON_Material::IsPhysicallyBased() const | bool ON_Material::IsPhysicallyBased(void) const
{
//Optimized version
const auto pUD = static_cast<ON_PhysicallyBasedMaterialUserData*>(GetUserData(ON_CLASS_ID(ON_PhysicallyBasedMaterialUserData)));
if (nullptr == pUD)
return false;
//https://mcneel.myjetbrains.com/youtrack/issue/RH-68577
return pUD->m_p... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x4ab75d(%rip), %rdi # 0xa7ee58
callq 0x330230
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x307fa0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -... | /mcneel[P]opennurbs/opennurbs_material.cpp |
ON_Material::ToPhysicallyBased() | void ON_Material::ToPhysicallyBased(void)
{
if (IsPhysicallyBased())
return;
//This should always be valid.
auto pbr = std::make_shared<ON_PhysicallyBasedMaterial>(*this);
ON_ASSERT(pbr != nullptr);
const bool bMetal = m_transparency < 0.01 && !m_bFresnelReflections && m_reflectivity > 0.99;
const boo... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x31cb10
testb $0x1, %al
jne 0x5d3892
jmp 0x5d3897
jmp 0x5d3b19
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x32a180
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, -0x44... | /mcneel[P]opennurbs/opennurbs_material.cpp |
PTCHelper(IClosestPointMapper const&, ON_Mesh const&, ON_3fVector const&, ON_3dPoint const*, int, int, int, ON_3dPoint*) | static void PTCHelper(const IClosestPointMapper& mapper, const ON_Mesh & meshTo, const ON_3fVector & vtFaceNormal, const ON_3dPoint * vtx, int i0, int i1, int i2, ON_3dPoint * tOut)
{
const double n = 3.0;
const double m = (n + 1.0) / (n - 1.0);
const double k = 1.0 / (n - 1.0);
ON_3dPoint sample_points[3];
samp... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movsd 0x301086(%rip), %xmm0 # 0x8d5978
movsd %xmm0, -0x30(%rbp)
mov... | /mcneel[P]opennurbs/opennurbs_material.cpp |
EvBoxSideTextureCoordinateHelper1(ON_Mesh const&, ON_Xform const*, int, int, ON_TextureMapping const&, float*, float*) | static
bool EvBoxSideTextureCoordinateHelper1(
const ON_Mesh& mesh,
const ON_Xform* mesh_xform,
int vi,
int side,
const ON_TextureMapping& box_mapping,
float* Tx,
float* Ty
)
{
bool rc = false;
ON_3dPoint P, tc;
ON_3dVector N(0.0,0.0,0... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
leaq -0x78(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %... | /mcneel[P]opennurbs/opennurbs_material.cpp |
ON_ClassArray<ON_Texture>::Append(ON_Texture const&) | void ON_ClassArray<T>::Append( const T& x )
{
if ( m_count == m_capacity )
{
const int newcapacity = NewCapacity();
if (m_a)
{
const int s = (int)(&x - m_a); // (int) cast is for 64 bit pointers
if ( s >= 0 && s < m_capacity )
{
// 26 Sep 2005 Dale Lear
// User pas... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x230(%rbp)
movl 0x10(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x5d6854
movq -0x230(%rbp), %rdi
callq 0x30f070
movl %eax, %ecx
movq -0x230(%rbp), %rax
movl %ecx, -0x14(%rbp)
... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
CMeshClosestPointMapper::CMeshClosestPointMapper(ON_Mesh const&, ON_2fPointArray const&, ON_RenderMeshInfo const*, ON_Xform const&) | CMeshClosestPointMapper(const ON_Mesh& mesh, const ON_2fPointArray& tc, const ON_RenderMeshInfo* pRenderMeshInfo, const ON_Xform& objectXform)
: m_mesh(mesh),
m_tc(tc),
m_pMappingMeshInfo(mesh.GetMappingMeshInfo()),
m_pRenderMeshInfo(pRenderMeshInfo),
m_objectXform(objectXform),
m_pSourceCPM(nullptr),
m_to... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3365f0
movq -0x58(%rbp), %rax
movq 0x4a66c1(%rip), %rcx # 0xa7d898
addq $0x10, %rcx
movq %rcx, (%rax)
movq ... | /mcneel[P]opennurbs/opennurbs_material.cpp |
ON_ClassArray<ON_TextureCoordinates>::Remove(int) | void ON_ClassArray<T>::Remove( int i )
{
if ( i >= 0 && i < m_count )
{
DestroyElement( m_a[i] );
// This call to memset is ok even when T has a vtable
// because in-place construction is used later.
memset( (void*)(&m_a[i]), 0, sizeof(T) );
Move( i, i+1, m_count-1-i );
// This call to mems... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x5d806b
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x5d806b
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rsi
movslq -0xc(%rbp), %rax
imulq... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_PhysicallyBasedMaterial::Impl::UserData() const | const ON_PhysicallyBasedMaterialUserData& UserData() const
{
const auto pUD = material->GetUserData(ON_CLASS_ID(ON_PhysicallyBasedMaterialUserData));
if (pUD)
{
return static_cast<const ON_PhysicallyBasedMaterialUserData&>(*pUD);
}
if (m_pDummy)
{
return *m_pDummy;
}
//Th... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq 0x4a6a06(%rip), %rdi # 0xa7ee58
callq 0x330230
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x307fa0
movq... | /mcneel[P]opennurbs/opennurbs_material.cpp |
ON_PhysicallyBasedMaterialUserData::Parameters::IsValid(ON_TextLog*) const | bool IsValid(class ON_TextLog* text_log = nullptr) const
{
//!base_color.IsValid() means that PBR is not supported.
//if (!base_color.IsValid()) return false;
if (ON_UNSET_VALUE == subsurface) return false;
if (!subsurface_scattering_color.IsValid()) return false;
if (ON_IS_UNSET_DOUBL... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x2fb158(%rip), %xmm0 # 0x8d3768
ucomisd 0x10(%rax), %xmm0
jne 0x5d8622
jp 0x5d8622
movb $0x0, -0x1(%rbp)
jmp 0x5d898f
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
m... | /mcneel[P]opennurbs/opennurbs_material.cpp |
ON_PhysicallyBasedMaterialUserData::Read(ON_BinaryArchive&) | bool Read(ON_BinaryArchive& archive) override
{
int chunk_version = 0;
if (false == archive.BeginRead3dmAnonymousChunk(&chunk_version))
return false;
bool rc = false;
if (chunk_version == 1 || chunk_version == 2)
{
rc = m_parameters.Read(archive, chunk_version);
}
if (!archi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x31b760
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x5d94fd
movb $0x0, -0x1(%rbp)
j... | /mcneel[P]opennurbs/opennurbs_material.cpp |
CTtRenderMeshInfoUserData::CTtRenderMeshInfoUserData() | CTtRenderMeshInfoUserData()
{
m_application_uuid = ON_opennurbs_id;
m_userdata_uuid = ON_CLASS_ID(CTtRenderMeshInfoUserData);
m_userdata_copycount = 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3127d0
movq -0x30(%rbp), %rdi
movq 0x4a4814(%rip), %rax # 0xa7e088
addq $0x10, %rax
movq %rax, (%rdi)
addq $0xc8, %rdi
callq 0x316e50
jmp 0x5d9889
movq -0x30(%rbp), %rax
movq 0x4a5054(%rip), %rcx ... | /mcneel[P]opennurbs/opennurbs_material.cpp |
CMeshClosestPointMapper::SeamTool::Data::Set(ON_SimpleArray<int> const&, ON_SimpleArray<int> const&) | void Set(const ON_SimpleArray<int>& seamless, const ON_SimpleArray<int>& seamed)
{
if (seamless.Count() <= capacity)
m_nSeamless = seamless.Count();
else
m_nSeamless = capacity;
for (int i = 0; i < m_nSeamless; i++)
m_neighbourFis[i] = seamless[i];
if... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x317860
cmpl $0x4, %eax
jg 0x5dbb8e
movq -0x10(%rbp), %rdi
callq 0x317860
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)... | /mcneel[P]opennurbs/opennurbs_material.cpp |
ON_SimpleArray<ON__CNewMeshFace>::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 0x5e0792
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x5e07ad
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_TextureCoordinates*>::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 0x5e2e82
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x5e2eaa
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_SimpleArray<ON_SurfaceCurvature>::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 $0x4, %rax
cmpq $0x10000000, %rax # imm = 0x10000000
jbe 0x5e2fa2
movq -0x28(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jge 0x5e2fca
movq -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_ClassArray<ON_TextureCoordinates>::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 0x5e3142
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x5e315d
movl $0xffffffff, %eax # im... | /mcneel[P]opennurbs/opennurbs_array_defs.h |
ON_Matrix::RowReduce(double, double&, double&) | int
ON_Matrix::RowReduce(
double zero_tolerance,
double& determinant,
double& pivot
)
{
double x, piv, det;
int i, k, ix, rank;
double** this_m = ThisM();
piv = det = 1.0;
rank = 0;
const int n = m_row_count <= m_col_count ? m_row_count : m_col_count;
for ( k = 0; k < n; k++ ) {
ix ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2fcbb0
movq -0x60(%rbp), %rcx
movq %rax, -0x50(%rbp)
movsd 0x2dc3aa(%rip), %xmm0 # 0x8d3000
movsd %xmm0, -0x38(%rbp)
movsd 0x2dc... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_Matrix::RowReduce(double, double*, double*) | int
ON_Matrix::RowReduce(
double zero_tolerance,
double* B,
double* pivot
)
{
double t;
double x, piv;
int i, k, ix, rank;
double** this_m = ThisM();
piv = 0.0;
rank = 0;
const int n = m_row_count <= m_col_count ? m_row_count : m_col_count;
for ( k = 0; k < n; k++ ) {
ix = k;
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2fcbb0
movq -0x60(%rbp), %rcx
movq %rax, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x48(%rbp)
movl 0x10(... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_Matrix::RowReduce(double, ON_3dPoint*, double*) | int
ON_Matrix::RowReduce(
double zero_tolerance,
ON_3dPoint* B,
double* pivot
)
{
ON_3dPoint t;
double x, piv;
int i, k, ix, rank;
double** this_m = ThisM();
piv = 0.0;
rank = 0;
const int n = m_row_count <= m_col_count ? m_row_count : m_col_count;
for ( k = 0; k < n; k++ ) {
//on... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2fcbb0
movq -0xa0(%rbp), %rcx
movq %rax, -0x60(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x58(%rbp)
movl 0x10(... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_Matrix::BackSolve(double, int, int, int, double const*, int, double*) const | bool
ON_Matrix::BackSolve(
double zero_tolerance,
int pt_dim,
int Bsize,
int Bpt_stride,
const double* Bpt,
int Xpt_stride,
double* Xpt
) const
{
const int sizeof_pt = pt_dim*sizeof(double);
double mij;
int i, j, k;
const double* Bi;
double* Xi;
double* Xj;
if ( m_col_cou... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
movl ... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_Matrix::Zero() | void ON_Matrix::Zero()
{
struct DBLBLK* cmem = (struct DBLBLK*)m_cmem;
while ( 0 != cmem )
{
if ( 0 != cmem->a && cmem->count > 0 )
{
memset( cmem->a, 0, cmem->count*sizeof(cmem->a[0]) );
}
onmalloc(0); // allow canceling
cmem = cmem->next;
}
//m_a.Zero();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x5f8436
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
je 0x5f841f
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x5f841f
movq -0x10... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_Matrix::IsRowOrthoganal() const | bool ON_Matrix::IsRowOrthoganal() const
{
double d0, d1, d;
int i0, i1, j;
double const*const* this_m = ThisM();
bool rc = ( m_row_count <= m_col_count && m_row_count > 0 );
for ( i0 = 0; i0 < m_row_count && rc; i0++ ) for ( i1 = i0+1; i1 < m_row_count && rc; i1++ ) {
d0 = d1 = d = 0.0;
for ( j = 0; j... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3267e0
movq -0x48(%rbp), %rdx
movq %rax, -0x38(%rbp)
movl 0x10(%rdx), %ecx
xorl %eax, %eax
cmpl 0x14(%rdx), %ecx
movb %al, -0x3a(%rbp)
jg 0x5f86bc
movq -0x48(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setg %al
... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_Matrix::Add(ON_Matrix const&, ON_Matrix const&) | bool ON_Matrix::Add( const ON_Matrix& a, const ON_Matrix& b )
{
int i, j;
if (a.ColCount() != b.ColCount() )
return false;
if (a.RowCount() != b.RowCount() )
return false;
if ( a.RowCount() < 1 || a.ColCount() < 1 )
return false;
if ( this != &a && this != &b ) {
Create( a.RowCount(), b.ColCou... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x318330
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
callq 0x318330
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
je 0x5f... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_Matrix::Scale(double) | bool ON_Matrix::Scale( double s )
{
bool rc = false;
if ( m_row_count > 0 && m_col_count > 0 )
{
struct DBLBLK* cmem = (struct DBLBLK*)m_cmem;
int i;
double* p;
while ( 0 != cmem )
{
if ( 0 != cmem->a && cmem->count > 0 )
{
p = cmem->a;
i = cmem->count;
whi... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
cmpl $0x0, 0x10(%rax)
jle 0x5f95f1
movq -0x38(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x5f95f1
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
c... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_RowReduce(int, int, double, double**, double**, double*) | int ON_RowReduce( int row_count,
int col_count,
double zero_pivot,
double** A,
double** B,
double pivots[2]
)
{
// returned A is identity, B = inverse of input A
const int M = row_count;
const int N = co... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movslq -0x38(%rbp), %rax
shlq $0x3, %rax
movq %ra... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
CompareDoubleIncreasing(void const*, void const*) | static int CompareDoubleIncreasing(const void* a, const void* b)
{
double x = *((const double*)a);
double y = *((const double*)b);
if (x < y)
return -1;
if (x > y)
return 1;
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5fb25f
movl $0xffffffff, -0x4(%rbp... | /mcneel[P]opennurbs/opennurbs_matrix.cpp |
ON_MD5::AccumulateBytes(void const*, unsigned long) | void ON_MD5::AccumulateBytes(
const void* buffer,
ON__UINT64 sizeof_buffer
)
{
if (nullptr != buffer && sizeof_buffer > 0)
{
if (1 != (1 & m_status_bits))
Reset();
m_status_bits = 1; // invalidate any intermediate cached m_digest value.
m_byte_count += sizeof_buffer;
const ON__UINT32 max... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x5fc270
cmpq $0x0, -0x18(%rbp)
jbe 0x5fc270
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
andl $0x1, %ecx
movl $0x1, %eax
... | /mcneel[P]opennurbs/opennurbs_md5.cpp |
ON_MD5_Hash::FileHash(char const*, unsigned long&) | ON_MD5_Hash ON_MD5_Hash::FileHash(
const char* filename,
ON__UINT64& sizeof_file
)
{
FILE* fp =
( nullptr == filename || 0 == filename[0] )
? nullptr
: ON_FileStream::Open(filename, "rb");
ON_MD5_Hash md5_hash = ON_MD5_Hash::FileHash(fp,sizeof_file);
ON_FileStream::Close(fp);
return md5_hash... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x5fc4d5
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x5fc4dd
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x5fc4f1
movq -0x18(%rbp), %rdi
leaq 0x2dd8d0(%r... | /mcneel[P]opennurbs/opennurbs_md5.cpp |
ON_MD5::set_final_hash() | void ON_MD5::set_final_hash()
{
// MD5 finalization.
// Ends an MD5 message-digest operation and writes the message digest.
static unsigned char padding[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
addq $0x50, %rsi
movl $0x8, %edx
callq 0x5fd9b0
movq -0x20(%rbp), %rax
movl 0x50(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
cmpl $0x38, -0x14(%rbp)
jae 0x5fcef9
... | /mcneel[P]opennurbs/opennurbs_md5.cpp |
onmemdup | void* onmemdup( const void* src, size_t sz )
{
void* p;
if ( src && sz>0 )
{
p = onmalloc(sz);
if (p)
memcpy(p,src,sz);
}
else {
p = 0;
}
return p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5fdd95
cmpq $0x0, -0x10(%rbp)
jbe 0x5fdd95
movq -0x10(%rbp), %rdi
callq 0x307b10
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5fdd93
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %r... | /mcneel[P]opennurbs/opennurbs_memory_util.cpp |
ON_MeshFace::IsValid(int, ON_3dPoint const*) const | bool
ON_MeshFace::IsValid(int mesh_vertex_count, const ON_3dPoint* V ) const
{
if ( !IsValid(mesh_vertex_count) )
return false;
if ( !(V[vi[0]] != V[vi[1]]) )
return false;
if ( !(V[vi[0]] != V[vi[2]]) )
return false;
if ( !(V[vi[1]] != V[vi[2]]) )
return false;
if ( vi[2] != vi[3] )
{
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %esi
callq 0x301910
testb $0x1, %al
jne 0x5febe0
movb $0x0, -0x1(%rbp)
jmp 0x5fed22
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movslq (%rax)... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshFace::Repair(int, ON_3fPoint const*) | bool ON_MeshFace::Repair(
int mesh_vertex_count,
const ON_3fPoint* V
)
{
ON_MeshFace f;
int fvi_count = 0;
f.vi[0] = f.vi[1] = f.vi[2] = f.vi[3] = -1;
if ( vi[0] >= 0 && vi[0] < mesh_vertex_count && V[vi[0]].IsValid() )
f.vi[fvi_count++] = vi[0];
if (vi[1] >= 0 && vi[1] < mesh_vertex_count && f.... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x2c(%rbp) # imm = 0x... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshFace::Repair(int, ON_3dPoint const*) | bool ON_MeshFace::Repair(
int mesh_vertex_count,
const ON_3dPoint* V
)
{
ON_MeshFace f;
int fvi_count = 0;
f.vi[0] = f.vi[1] = f.vi[2] = f.vi[3] = -1;
if ( vi[0] >= 0 && vi[0] < mesh_vertex_count && V[vi[0]].IsValid() )
f.vi[fvi_count++] = vi[0];
if (vi[1] >= 0 && vi[1] < mesh_vertex_count && f.... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x34(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x2c(%rbp) # imm = 0x... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::ON_Mesh(ON_Mesh const&) | ON_Mesh::ON_Mesh( const ON_Mesh& src )
: m_packed_tex_rotate(0)
, m_parent(0)
, m_mesh_parameters(0)
, m_invalid_count(0)
, m_quad_count(0)
, m_triangle_count(0)
, m_mesh_is_closed(0)
, m_mesh_is_manifold(0)
, m_mesh_is_oriented(0)
, m_mesh_is_solid(0)
{
// Do not copy m_mesh_cache. Cached information will
// ... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x336a30
movq -0x30(%rbp), %rdi
movq 0x47e41d(%rip), %rax # 0xa7e3c8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0x28(%rbp)
callq 0x31faf0
jmp 0x5fffc1
movq ... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshNgon::IsValid(ON_MeshNgon const*, unsigned int, ON_TextLog*, unsigned int, unsigned int, ON_MeshFace const*, ON_SimpleArray<unsigned int>&) | unsigned int ON_MeshNgon::IsValid(
const ON_MeshNgon* ngon,
unsigned int ngon_index,
ON_TextLog* text_logx,
unsigned int mesh_vertex_count,
unsigned int mesh_face_count,
const ON_MeshFace* mesh_F,
ON_SimpleArray< unsigned int >& workspace_buffer
)
{
workspace_buffer.SetCount(0);
if ( nullptr == ngon... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x308bf0
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x600b84
movl $0x1, -... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
compare2u(void const*, void const*) | static int compare2u(const void* a, const void*b)
{
unsigned int x = ((const unsigned int*)a)[0];
unsigned int y = ((const unsigned int*)b)[0];
if ( x < y)
return -1;
if ( x > y)
return 1;
x = ((const unsigned int*)a)[1];
y = ((const unsigned int*)b)[1];
if ( x < y)
return -1;
if ( x > y)
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x60138f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6013dd... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::Dump(ON_TextLog&) const | void ON_Mesh::Dump( ON_TextLog& dump ) const
{
const int half_max = 8;
const int fcount = m_F.Count();
int i;
const int vcount = m_V.Count();
ON_3dPoint p, q;
bool bDoubles = vcount > 0
&& HasDoublePrecisionVertices()
&& HasSynchronizedDoubleAndSinglePrecisionVertic... | pushq %rbp
movq %rsp, %rbp
subq $0x510, %rsp # imm = 0x510
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x260(%rbp)
movl $0x8, -0x14(%rbp)
addq $0x40, %rdi
callq 0x305340
movq -0x260(%rbp), %rdi
movl %eax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x328f90
movl %eax, -0x20(%rbp)
xo... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshParameters::GeometrySettingsType(bool) const | enum ON_MeshParameters::Type ON_MeshParameters::GeometrySettingsType(bool bIgnoreSubDParameters) const
{
const ON_SHA1_Hash mp_hash = GeometrySettingsHash(bIgnoreSubDParameters);
if ( mp_hash == ON_MeshParameters::DefaultMesh.GeometrySettingsHash(bIgnoreSubDParameters))
return ON_MeshParameters::Type::Default;... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x88(%rbp)
movb -0x11(%rbp), %al
leaq -0x25(%rbp), %rdi
andb $0x1, %al
movzbl %al, %edx
callq 0x325360
movb -0x11(%rbp), %al
leaq -0x39(%rbp), %rdi
movq 0x478d07(%rip... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::Write_2(int, ON_BinaryArchive&) const | bool ON_Mesh::Write_2( int Vcount, ON_BinaryArchive& file ) const
{
// ver 2.0 compressed format
const ON::endian e = file.Endian();
bool rc = true;
if ( Vcount > m_V.Count() )
return false;
if ( Vcount > 0 )
{
const int Ncount = (m_V.Count() == m_N.Count()) ? Vcount : 0;
const int Tcount = ... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x32bac0
movq -0x48(%rbp), %rdi
movl %eax, -0x24(%rbp)
movb $0x1, -0x25(%rbp)
movl -0x14(%rbp), %eax
movl ... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::Read_2(int, ON_BinaryArchive&) | bool ON_Mesh::Read_2( int vcount, ON_BinaryArchive& file )
{
// common to all 2.x formats (compressed)
const ON::endian e = file.Endian();
bool rc = true;
if ( vcount > 0 )
{
size_t sz = 0;
bool bFailedCRC;
sz = 0;
if (rc) rc = file.ReadCompressedBufferSize( &sz );
if (rc && sz)
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32bac0
movl %eax, -0x1c(%rbp)
movb $0x1, -0x1d(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x60692b
movq $0x0, -0x28(%rbp)
movq $0x0, -0x28(%rbp)... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::Write(ON_BinaryArchive&) const | bool ON_Mesh::Write( ON_BinaryArchive& file ) const
{
int i;
//const int major_version = 1; // uncompressed
//const int major_version = 2; // beta format (never used)
const int major_version = 3; // compressed
const int minor_version
= (file.Archive3dmVersion() >= 60)
//? 6 // ngons saved in V6 fi... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x3, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x305d20
movl %eax, %edx
movl $0x5, %eax
movl $0x8, %ecx
cmpl $0x3c, %edx
cmovgel %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), ... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_TextureMapping::Internal_WriteV5(ON_BinaryArchive&) const | bool ON_TextureMapping::Internal_WriteV5(
ON_BinaryArchive& file
) const
{
bool rc = file.BeginWrite3dmChunk(TCODE_ANONYMOUS_CHUNK,1,1);
if (rc)
{
for(;;)
{
rc = file.WriteUuid( Id() );
if (!rc) break;
rc = file.WriteInt( static_cast<unsigned int>(m_type) );
if (!rc) break;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40008000, %esi # imm = 0x40008000
movl $0x1, %ecx
movl %ecx, %edx
callq 0x305e30
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x60... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ReadMeshNgons(ON_BinaryArchive&, ON_MeshNgonAllocator&, ON_SimpleArray<ON_MeshNgon*>&) | static
bool ReadMeshNgons( ON_BinaryArchive& file, ON_MeshNgonAllocator& a, ON_SimpleArray<ON_MeshNgon*>& ngons )
{
ngons.SetCount(0);
int major_version = 0;
int minor_version = 0;
unsigned int i, Vcount, Fcount;
if ( !file.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version) )
return f... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x2fb8e0
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40008000, %esi # imm = 0x40008000
leaq -0x24(%rbp), %rdx
leaq -0x28(%r... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ReadMeshDoublePrecisionVertices(ON_BinaryArchive&, ON_SimpleArray<ON_3dPoint>&) | static
bool ReadMeshDoublePrecisionVertices(
ON_BinaryArchive& file,
ON_SimpleArray<ON_3dPoint>& dV
)
{
dV.SetCount(0);
int major_version = 0;
int minor_version = 0;
if ( !file.BeginRead3dmChunk(TCODE_ANONYMOUS_CHUNK,&major_version,&minor_version) )
return false;
bool rc = false;
for(;;)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2fc980
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40008000, %esi # imm = 0x40008000
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x30118... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::GetBBox(double*, double*, bool) const | bool ON_Mesh::GetBBox( // returns true if successful
double* boxmin, // minimum
double* boxmax, // maximum
bool bGrowBox
) const
{
bool rc = false;
const unsigned int facet_count = FaceCount();
const unsigned int vertex_count = VertexCount();
if ( facet_count >= 1 && vertex_count >=... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %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, -0xc8(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x334f60
movq -0xc8(%rbp), %rdi
movl %eax, -0x20(%rbp)
callq 0x3385a0
movl %eax, -0... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::ComputeVertexNormals() | bool ON_Mesh::ComputeVertexNormals()
{
bool rc = false;
const int fcount = FaceCount();
const int vcount = VertexCount();
int vi, fi, j;
ON_3fVector n;
if ( fcount > 0 && vcount > 0 ) {
rc = HasFaceNormals();
if ( !rc )
rc = ComputeFaceNormals();
if ( rc ) {
ON_Workspace ws;
/... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x334f60
movq -0x88(%rbp), %rdi
movl %eax, -0x10(%rbp)
callq 0x3385a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x60b1c8
cmpl $0x0, -0x14(%rbp)
jle 0x60b1c8
movq -0x88(%rbp)... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshCurvatureStats::Set(ON::curvature_style, int, ON_SurfaceCurvature const*, ON_3fVector const*, double) | bool ON_MeshCurvatureStats::Set( ON::curvature_style kappa_style,
int Kcount,
const ON_SurfaceCurvature* K,
const ON_3fVector* N, // needed for normal sectional curvatures
double infinity
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x61(%rbp)
jle 0x60b3e0
cmpq $0x0, -0x18(%rb... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::SetSolidOrientation(int) | void ON_Mesh::SetSolidOrientation(int solid_orientation)
{
switch(solid_orientation)
{
case -1: // closed oriented manifold solid with inward face normals
SetClosed(1);
m_mesh_is_manifold = 1;
m_mesh_is_oriented = 1;
m_mesh_is_solid = 2;
break;
case 0: // not solid
m_mesh_is_solid = 3;... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $-0x1, %eax
je 0x60bfc7
jmp 0x60bfb4
movl -0x10(%rbp), %eax
testl %eax, %eax
je 0x60bff0
jmp 0x60bfbd
movl -0x10(%rbp), %eax
subl $0x1, %... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::SolidOrientation() const | int ON_Mesh::SolidOrientation() const
{
if ( m_mesh_is_solid <= 0 || m_mesh_is_solid > 3 )
{
// NOTE: calling IsClosed() will set m_mesh_is_solid
// to 3 if mes is non-manifold
if ( IsSolid() )
{
}
}
switch(m_mesh_is_solid)
{
case 1:
return 1;
break;
case 2:
return... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x417(%rax), %eax
cmpl $0x0, %eax
jle 0x60cad0
movq -0x18(%rbp), %rax
movsbl 0x417(%rax), %eax
cmpl $0x3, %eax
jle 0x60cae3
movq -0x18(%rbp), %rdi
callq 0x317160
testb $0x1, %al
jne 0x60cadf
jmp 0x60c... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh_SetClosedHelper(bool, ON_Mesh const&, char const&, char const&) | static void ON_Mesh_SetClosedHelper(
bool bClosedOnly,
const ON_Mesh& mesh,
const char& m_mesh_is_manifold,
const char& m_mesh_is_oriented
)
{
// thread safe lazy evaluation for mesh's m_mesh_is_... flags
// Sets: m_mesh_is_closed.
// If bClosedOnly is fals... | pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp # imm = 0x490
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movb $0x2, -0x25(%rbp)
movb $0x2, -0x26(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x325150
movl %... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::SetVertex(int, ON_3fPoint const&) | bool ON_Mesh::SetVertex(
int vertex_index,
const ON_3fPoint& vertex_location
)
{
const unsigned int vertex_count = VertexUnsignedCount();
const bool rc = vertex_index >= 0 && ((unsigned int)vertex_index) <= vertex_count;
if ( rc )
{
const unsigned int i = (unsigned int)vertex_index;
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x32c2e0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x41(%rbp)
jl 0x60df1d
movl -0xc(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setbe %al... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::SetVertexNormal(int, ON_3dVector const&) | bool ON_Mesh::SetVertexNormal(
int vertex_index,
const ON_3dVector& normal
)
{
bool rc = false;
// use double precision for unitizing normal
ON_3dVector unit_vector = normal;
const bool bUnitVector = unit_vector.Unitize();
ON_3fVector v((float)unit_vector.x, (float)unit_vector.y, (float)u... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%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_mesh.cpp |
ON_Mesh::AppendDuplicateVertex(unsigned int) | unsigned int ON_Mesh::AppendDuplicateVertex(
unsigned int vertex_index
)
{
const unsigned int vertex_count = VertexUnsignedCount();
if ( vertex_index >= vertex_count )
return ON_UNSET_UINT_INDEX;
if (vertex_count == m_V.UnsignedCount())
{
ON_3fPoint V = m_V[vertex_index];
m_V.Append(V);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x32c2e0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jb 0x60e269
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x60e567
movq -0x88(%rbp), %rdi
movl... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh_Private_AddPerVertexMappingChannels(std::function<ON_TextureMapping (ON_MappingChannel const*)>, ON_MappingRef const*, ON_SimpleArray<ON_TextureMapping::TYPE> const&, ON_Material const&, std::unordered_map<unsigned int, ON_TextureMapping, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std:... | ON_DECL bool ON_Mesh_Private_AddPerVertexMappingChannels(std::function<ON_TextureMapping(const ON_MappingChannel*)> get_texture_mapping_func, const ON_MappingRef* mapping_ref, const ON_SimpleArray<ON_TextureMapping::TYPE>& mappings_to_cache, const ON_Material& material, std::unordered_map<unsigned int, ON_TextureMappin... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xc8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0xcc(%rbp)
movq -0x28(%rbp), %rdi
addq $0xf8, %rdi
call... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_SurfaceDraftAngleColorMapping::ColorMappingTag() const | const ON_MappingTag ON_SurfaceDraftAngleColorMapping::ColorMappingTag() const
{
ON_MappingTag mt = ON_MappingTag::Unset;
if (this->IsSet())
{
mt.m_mapping_id = ON_SurfaceDraftAngleColorMapping::Id;
mt.m_mapping_type = ON_TextureMapping::TYPE::false_colors;
// DO NOT INCLUDE anything in the crc that ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x46d442(%rip), %rsi # 0xa7dee8
movl $0x98, %edx
callq 0x2fcd50
movq -0x10(%rbp), %rdi
callq 0x317110
testb $0x1, %al
jne 0x610abf
jmp 0x61... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_SurfaceCurvatureColorMapping::ColorMappingTag() const | const ON_MappingTag ON_SurfaceCurvatureColorMapping::ColorMappingTag() const
{
ON_MappingTag mt = ON_MappingTag::Unset;
if (this->IsSet())
{
mt.m_mapping_id = ON_SurfaceCurvatureColorMapping::Id;
mt.m_mapping_type = ON_TextureMapping::TYPE::false_colors;
// DO NOT INCLUDE anything in the crc that do... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x46cec2(%rip), %rsi # 0xa7dee8
movl $0x98, %edx
callq 0x2fcd50
movq -0x10(%rbp), %rdi
callq 0x319b90
testb $0x1, %al
jne 0x61103f
jmp 0x61... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::UnitizeFaceNormals() | bool ON_Mesh::UnitizeFaceNormals()
{
bool rc = HasFaceNormals();
if ( rc ) {
const int face_count = FaceCount();
float* n = &m_FN[0][0];
int i;
ON_3dVector N;
for ( i = 0; i < face_count; i++ ) {
N.x = n[0];
N.y = n[1];
N.z = n[2];
if ( !N.Unitize() )
rc = false;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x308690
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x611391
movq -0x40(%rbp), %rdi
callq 0x334f60
movq -0x40(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0x148, %rdi # imm = 0x... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_UnsetMeshFaceInitalizer() | static ON_MeshFace ON_UnsetMeshFaceInitalizer()
{
ON_MeshFace unset_mesh_face;
unset_mesh_face.vi[0] = -1;
unset_mesh_face.vi[1] = -1;
unset_mesh_face.vi[2] = -1;
unset_mesh_face.vi[3] = -1;
return unset_mesh_face;
} | pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::Flip() | void
ON_Mesh::Flip()
{
FlipFaceOrientation();
FlipFaceNormals();
FlipVertexNormals();
FlipNgonOrientation();
// Do not modify m_S[] or m_T[]
// values here.
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x31bab0
movq -0x10(%rbp), %rdi
callq 0x2fb210
movq -0x10(%rbp), %rdi
callq 0x339db0
movq -0x10(%rbp), %rdi
callq 0x319470
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshFace::ComputeFaceNormal(ON_3fPoint const*, ON_3dVector&) const | bool ON_MeshFace::ComputeFaceNormal( const ON_3fPoint* fV, ON_3dVector& FN ) const
{
if ( 0 != fV )
{
ON_3dVector a = fV[vi[2]] - fV[vi[0]];
ON_3dVector b = fV[vi[3]] - fV[vi[1]];
FN = ON_CrossProduct( a, b ); // works for triangles, quads, and nonplanar quads
if ( FN.Unitize() )
return true;
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x613142
movq -0xb0(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq 0x8(%rcx), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshFace::ComputeFaceNormal(ON_3dPointListRef const&, ON_3dVector&) const | bool ON_MeshFace::ComputeFaceNormal( const class ON_3dPointListRef& vertex_list, ON_3dVector& FN ) const
{
ON_3dVector a = vertex_list[vi[2]] - vertex_list[vi[0]];
ON_3dVector b = vertex_list[vi[3]] - vertex_list[vi[1]];
FN = ON_CrossProduct( a, b ); // works for triangles, quads, and nonplanar quads
if ( FN.Un... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rsi
movl 0x8(%rax), %edx
leaq -0x50(%rbp), %rdi
callq 0x3071e0
movq -0xd0(%rbp), %rax
movq -0x18(%rbp), %rsi
movl (%rax), %edx
leaq -0x68(%rbp... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::CombineCoincidentVertices(ON_3fVector, double) | bool ON_Mesh::CombineCoincidentVertices(
const ON_3fVector tolerance,
double cos_normal_angle // = -1.0 // cosine(break angle) -1.0 will merge all coincident vertices
)
{
// TODO - If you need this function, please ask Dale Lear to finish it.
//bool rc = false;
//const int vcount = Verte... | pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
xorl %eax, %eax
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
| /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::CombineIdenticalVertices(bool, bool) | bool ON_Mesh::CombineIdenticalVertices(
bool bIgnoreVertexNormals,
bool bIgnoreTextureCoordinates
)
{
// 11 June 2003 - added and tested.
bool rc = false;
ON_Mesh& mesh = *this;
int vertex_count = mesh.m_V.Count();
... | pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
movb $0x0, -0xb(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::Compact() | bool ON_Mesh::Compact()
{
unsigned int meshVcount = m_V.UnsignedCount();
unsigned int meshFcount = m_F.UnsignedCount();
if (m_FN.UnsignedCount() != meshFcount)
m_FN.Destroy();
if (m_N.UnsignedCount() != meshVcount)
m_N.Destroy();
if (m_T.UnsignedCount() != meshVcount)
m_T.Destroy();
for (int... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0x325150
movq -0x20(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0x40, %rdi
callq 0x30e480
movq -0x20(%rbp), %rdi
movl %eax, -0x10(%rbp)
addq $0x148, %rdi # imm = 0x148
callq 0x329... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshParameters::MeshStyleFromUnsigned(unsigned int) | ON_MeshParameters::MESH_STYLE ON_MeshParameters::MeshStyleFromUnsigned(
unsigned int mesh_style_as_unsigned
)
{
switch (mesh_style_as_unsigned)
{
ON_ENUM_FROM_UNSIGNED_CASE(ON_MeshParameters::MESH_STYLE::unset_mesh_style);
ON_ENUM_FROM_UNSIGNED_CASE(ON_MeshParameters::MESH_STYLE::render_mesh_fast);
ON_ENUM_... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0xa, %rax
ja 0x618fba
movq -0x10(%rbp), %rax
leaq 0x2e5221(%rip), %rcx # 0x8fe1b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x618fdf
movb $0x1, -0x1(%rbp)
jmp 0x6... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshParameters::MeshParameterIdFromUnsigned(unsigned int) | ON_MeshParameters::MESH_PARAMETER_ID ON_MeshParameters::MeshParameterIdFromUnsigned(
unsigned int mesh_parameter_id_as_unsigned
)
{
switch (mesh_parameter_id_as_unsigned)
{
ON_ENUM_FROM_UNSIGNED_CASE(ON_MeshParameters::MESH_PARAMETER_ID::unspecified_mesh_parameter_id);
ON_ENUM_FROM_UNSIGNED_CASE(ON_MeshParame... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x23, %rax
ja 0x6191b2
movq -0x10(%rbp), %rax
leaq 0x2e51c9(%rip), %rcx # 0x8fe1e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x6191da
movl $0x1, -0x4(%rbp)
jmp 0x... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshParameters::SetTextureRangePictureFrameHack() | void ON_MeshParameters::SetTextureRangePictureFrameHack()
{
// A 2012 hack to fix cited issues. Search for calls in core Rhino
// code for comments with more details.
// Fix http://mcneel.myjetbrains.com/youtrack/issue/RH-17042
// Setting mp.TextureRange() = 0 here fixes RH-17042.
// What's one more... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq %rdi, %r8
addq $0x19, %r8
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x30c2d0
addq $0x10, %rsp
popq %rbp
retq
| /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshParameters::ON_MeshParameters(double, double) | ON_MeshParameters::ON_MeshParameters(
double normalized_mesh_density,
double min_edge_length
)
{
// non-default values
SetTextureRange(0);
SetGridAngleRadians(0.0);
SetGridAmplification(0.0);
SetRefineAngleRadians(0.0);
SetMinimumEdgeLength(min_edge_length);
if ( ON_IsValid(normalized_mesh_density)... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movb $0x0, (%rdi)
movb $0x1, 0x1(%rdi)
movb $0x0, 0x2(%rdi)
movb $0x0, 0x3(%rdi)
movb $0x1, 0x4(%rdi)
movb $0x0, 0x5(%rdi)
movb $0x0, 0x6(%rdi)
movb $0x0, 0x7(... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_MeshParameters::GeometrySettingsDensityPercentage(int) const | const int ON_MeshParameters::GeometrySettingsDensityPercentage(
int no_match_found_result
) const
{
const double slider_value = this->MeshDensity();
if (slider_value >= 0.0 && slider_value <= 1.0)
{
const int n = (int)floor(100.0 * slider_value + 0.4999);
if (n >= 0 && n <= 100)
return n;
/... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x308760
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x61b6c9
movsd 0x2b797d(%rip), %xmm0 # 0x8d3000
ucomisd -0x20(%rbp), %xmm0
jb 0x61b6c9
movsd -0x2... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_SurfaceCurvature::GaussianCurvature() const | double ON_SurfaceCurvature::GaussianCurvature() const
{
return (ON_IS_VALID(k1) && ON_IS_VALID(k2)) ? (k1 * k2) : ON_DBL_QNAN;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd (%rax), %xmm0
movsd 0x2b7adc(%rip), %xmm1 # 0x8d3768
ucomisd %xmm1, %xmm0
jbe 0x61bce2
movq -0x10(%rbp), %rax
movsd 0x2c292a(%rip), %xmm0 # 0x8de5c8
ucomisd (%rax), %xmm0
jbe 0x61bce2
movq -0x10(%rbp), %rax
movsd 0x8... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::CullDegenerateFaces() | unsigned int ON_Mesh::CullDegenerateFaces()
{
const unsigned int face_count0 = m_F.UnsignedCount();
DeleteComponents(
nullptr,
0,
true, // bIgnoreInvalidComponents
true, // bRemoveDegenerateFaces
false, // bRemoveUnusedVertices
true // bRemoveEmptyNgons
);
const unsigned int fa... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x40, %rdi
callq 0x30e480
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %r8d
xorl %r9d, %r9d
movq %rdx, %rsi
movl %r8d, %ecx
movl $0x1, (%rsp)
callq 0x320620
mov... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::ConvertQuadsToTriangles() | bool ON_Mesh::ConvertQuadsToTriangles()
{
double planar_tolerance = ON_UNSET_VALUE;
double angle_tolerance_radians = ON_UNSET_VALUE;
unsigned int split_method = 1;
ConvertNonPlanarQuadsToTriangles(
planar_tolerance,
angle_tolerance_radians,
split_method
);
return ( QuadCount() == 0 && Triangl... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movsd 0x2b63ec(%rip), %xmm0 # 0x8d3768
movsd %xmm0, -0x10(%rbp)
movsd 0x2b63df(%rip), %xmm0 # 0x8d3768
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movl... | /mcneel[P]opennurbs/opennurbs_mesh.cpp |
ON_Mesh::ReverseTextureCoordinates(int) | bool ON_Mesh::ReverseTextureCoordinates( int dir )
{
if ( dir < 0 || dir > 1 || !HasTextureCoordinates() )
return false;
bool bPackedRegion = HasPackedTextureRegion();
bool bSrfParamTag = (!m_Ttag.IsSet() || m_Ttag.IsDefaultSurfaceParameterMapping());
const int vcount = m_T.Count();
int i;
if ( bPac... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x61f580
cmpl $0x1, -0x14(%rbp)
jg 0x61f580
movq -0x50(%rbp), %rdi
callq 0x2fd310
testb $0x1, %al
jne 0x61f589
movb $0x0, -0x1(%rbp)
jmp 0x61f775
movq -0x50(%... | /mcneel[P]opennurbs/opennurbs_mesh.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.