name string | code string | asm string | file string |
|---|---|---|---|
p2t::Sweep::HoleAngle(p2t::Node const&) const | double Sweep::HoleAngle(const Node& node) const
{
/* Complex plane
* ab = cosA +i*sinA
* ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx)
* atan2(y,x) computes the principal value of the argument function
* applied to the complex number x+iy
* Where x = ax*bx + ay*by
* y = ax*by ... | movq (%rsi), %rax
movq 0x10(%rsi), %rcx
movq (%rcx), %rcx
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm2
movsd (%rax), %xmm3
movsd 0x8(%rax), %xmm4
subsd %xmm3, %xmm0
subsd %xmm4, %xmm2
movq 0x18(%rsi), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm5
subsd %xmm3, %xmm1
subsd %xmm4, %xmm5
movapd %xmm1, %xm... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc |
p2t::Sweep::FillLeftConcaveEdgeEvent(p2t::SweepContext&, p2t::Edge*, p2t::Node&) | void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
Fill(tcx, *node.prev);
if (node.prev->point != edge->p) {
// Next above or below edge?
if (Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) {
// Below
if (Orient2d(*node.point, *node.prev->point, *node.prev->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rcx), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5014ac
movq 0x18(%rbx), %rdx
movq (%rdx), %rax
movq (%r14), %rcx
cmpq %rcx, %rax
je 0x5029e2
movq 0x8(%r14), %rsi
movupd (%rax), %xmm0
movu... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc |
ClipperLib::Orientation(ClipperLib::OutRec*, bool) | bool Orientation(OutRec *outRec, bool UseFullInt64Range)
{
if (!outRec->pts)
return 0.0;
//first make sure bottomPt is correctly assigned ...
OutPt *opBottom = outRec->pts, *op = outRec->pts->next;
while (op != outRec->pts)
{
if (op->pt.Y >= opBottom->pt.Y)
{
if (op->pt.Y > opBottom->pt.Y |... | movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x504614
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq 0x18(%rcx), %rdx
cmpq %rcx, %rdx
je 0x504617
movq %rcx, %rax
movq 0x10(%rax), %r8
cmpq %r8, 0x10(%rdx)
jl 0x504609
jg 0x504606
movq 0x8(%rdx), %r8
cmpq 0x8(%rax), %r8
jge 0x504609
movq %rdx, %rax
movq 0x18(%rdx), %... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::InitEdge(ClipperLib::TEdge*, ClipperLib::TEdge*, ClipperLib::TEdge*, ClipperLib::IntPoint const&, ClipperLib::PolyType) | void InitEdge(TEdge *e, TEdge *eNext,
TEdge *ePrev, const IntPoint &pt, PolyType polyType)
{
std::memset( e, 0, sizeof( TEdge ));
e->next = eNext;
e->prev = ePrev;
e->xcurr = pt.X;
e->ycurr = pt.Y;
if (e->ycurr >= e->next->ycurr)
{
e->xbot = e->xcurr;
e->ybot = e->ycurr;
e->xtop = e->next->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movl $0x90, %edx
xorl %esi, %esi
callq 0x1a54e0
movq %r15, 0x58(%r14)
movq %r13, 0x60(%r14)
movq (%r12), %rax
movq %rax, 0x10(%r14)
movq 0x8(%r12), %rcx
movq %rcx, 0x18(%r14)
cmpq 0x18(... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::ClipperBase::InsertLocalMinima(ClipperLib::LocalMinima*) | void ClipperBase::InsertLocalMinima(LocalMinima *newLm)
{
if( ! m_MinimaList )
{
m_MinimaList = newLm;
}
else if( newLm->Y >= m_MinimaList->Y )
{
newLm->next = m_MinimaList;
m_MinimaList = newLm;
} else
{
LocalMinima* tmpLm = m_MinimaList;
while( tmpLm->next && ( newLm->Y < tmpLm->nex... | movq 0x10(%rdi), %rax
addq $0x10, %rdi
testq %rax, %rax
je 0x505ef4
movq (%rsi), %rcx
cmpq (%rax), %rcx
jge 0x505ef0
movq %rax, %rdi
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x505eec
cmpq (%rax), %rcx
jl 0x505edb
addq $0x18, %rdi
movq %rax, 0x18(%rsi)
movq %rsi, (%rdi)
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::~Clipper() | Clipper::~Clipper() //destructor
{
Clear();
DisposeScanbeamList();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq -0x18(%rax), %rax
movq %rcx, (%rdi,%rax)
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x5062a2
movq 0x8(%rdi), %r14
movl $0x10, %esi
callq 0x1a5190
movq %r14, 0x58(%rbx)
movq %... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::Reset() | void Clipper::Reset()
{
ClipperBase::Reset();
m_Scanbeam = 0;
m_ActiveEdges = 0;
m_SortedEdges = 0;
DisposeAllPolyPts();
LocalMinima* lm = m_MinimaList;
while (lm)
{
InsertScanbeam(lm->Y);
InsertScanbeam(lm->leftBound->ytop);
lm = lm->next;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x506028
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movq $0x0, 0x68(%rbx)
movq %rbx, %rdi
callq 0x5063e2
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0x10(%rbx,%rax), %r14
testq %r14, %r14
je 0x50649b
movq ... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::Execute(ClipperLib::ClipType, std::vector<ClipperLib::ExPolygon, std::allocator<ClipperLib::ExPolygon>>&, ClipperLib::PolyFillType, ClipperLib::PolyFillType) | bool Clipper::Execute(ClipType clipType, ExPolygons &solution,
PolyFillType subjFillType, PolyFillType clipFillType)
{
if( m_ExecuteLocked ) return false;
m_ExecuteLocked = true;
solution.resize(0);
m_SubjFillType = subjFillType;
m_ClipFillType = clipFillType;
m_ClipType = clipType;
bool succeeded = E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, 0x78(%rdi)
je 0x5066b2
xorl %ebp, %ebp
jmp 0x506700
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movb $0x1, 0x78(%rdi)
movq %rdx, %rdi
xorl %esi, %esi
callq 0x50ac3a
movl %r12d, 0x80(%rbx)
movl %ebp, 0x7c(%rbx)
movl %... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::ClearHorzJoins() | void Clipper::ClearHorzJoins()
{
for (HorzJoinList::size_type i = 0; i < m_HorizJoins.size(); i++)
delete m_HorizJoins[i];
m_HorizJoins.resize(0);
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0x38(%rdi), %rbx
movq 0x38(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x507068
movq %rdi, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl $0x10, %esi
callq 0x1a5190
incq %r15
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x507043
movq... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::ClearJoins() | void Clipper::ClearJoins()
{
for (JoinList::size_type i = 0; i < m_Joins.size(); i++)
delete m_Joins[i];
m_Joins.resize(0);
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0x20(%rdi), %rbx
movq 0x20(%rdi), %rax
cmpq %rax, 0x28(%rdi)
je 0x50811e
movq %rdi, %r14
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movl $0x50, %esi
callq 0x1a5190
incq %r15
movq 0x20(%r14), %rax
movq 0x28(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x5080f9
movq... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::AddJoin(ClipperLib::TEdge*, ClipperLib::TEdge*, int, int) | void Clipper::AddJoin(TEdge *e1, TEdge *e2, int e1OutIdx, int e2OutIdx)
{
JoinRec* jr = new JoinRec;
if (e1OutIdx >= 0)
jr->poly1Idx = e1OutIdx; else
jr->poly1Idx = e1->outIdx;
jr->pt1a = IntPoint(e1->xcurr, e1->ycurr);
jr->pt1b = IntPoint(e1->xtop, e1->ytop);
if (e2OutIdx >= 0)
jr->poly2Idx = e2O... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x50, %edi
callq 0x1a5230
movq %rax, 0x8(%rsp)
testl %r12d, %r12d
jns 0x508791
movl 0x54(%r15), %r12d
movl %r12d, 0x20(%rax)
movups 0x10(%r15), %xmm0
movups %xmm... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::GetLowermostRec(ClipperLib::OutRec*, ClipperLib::OutRec*) | OutRec* GetLowermostRec(OutRec *outRec1, OutRec *outRec2)
{
//work out which polygon fragment has the correct hole state ...
OutPt *outPt1 = outRec1->bottomPt;
OutPt *outPt2 = outRec2->bottomPt;
if (outPt1->pt.Y > outPt2->pt.Y) return outRec1;
else if (outPt1->pt.Y < outPt2->pt.Y) return outRec2;
else if (o... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
movq 0x10(%rsi), %rax
cmpq %rax, 0x10(%rdi)
jg 0x509150
jge 0x509146
movq %r14, %rbx
jmp 0x509150
movq 0x8(%rsi), %rax
cmpq %rax, 0x8(%rdi)
jge 0x50915b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
j... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::IsTopHorz(long long) | bool Clipper::IsTopHorz(const long64 XPos)
{
TEdge* e = m_SortedEdges;
while( e )
{
if( ( XPos >= std::min(e->xcurr, e->xtop) ) &&
( XPos <= std::max(e->xcurr, e->xtop) ) ) return false;
e = e->nextInSEL;
}
return true;
} | movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0x5096fd
movq 0x10(%rcx), %rax
movq 0x20(%rcx), %rdx
cmpq %rax, %rdx
movq %rax, %rdi
cmovlq %rdx, %rdi
cmpq %rsi, %rdi
setg %dil
cmpq %rdx, %rax
cmovgq %rax, %rdx
cmpq %rsi, %rdx
setl %al
orb %dil, %al
cmpb $0x1, %al
jne 0x5096fc
movq 0x80(%rcx), %rcx
testq %rcx, %rcx
jne 0x509... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Clipper::ProcessIntersectList() | void Clipper::ProcessIntersectList()
{
while( m_IntersectNodes )
{
IntersectNode* iNode = m_IntersectNodes->next;
{
IntersectEdges( m_IntersectNodes->edge1 ,
m_IntersectNodes->edge2 , m_IntersectNodes->pt, ipBoth );
SwapPositionsInAEL( m_IntersectNodes->edge1 , m_IntersectNodes->edge2 );... | movq 0x70(%rdi), %rcx
testq %rcx, %rcx
je 0x509e75
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rcx), %r14
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq $0x10, %rcx
movq %rbx, %rdi
movl $0x3, %r8d
callq 0x508bae
movq 0x70(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x509770
mov... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::ProcessParam1BeforeParam2(ClipperLib::IntersectNode&, ClipperLib::IntersectNode&) | bool ProcessParam1BeforeParam2(IntersectNode &node1, IntersectNode &node2)
{
bool result;
if (node1.pt.Y == node2.pt.Y)
{
if (node1.edge1 == node2.edge1 || node1.edge2 == node2.edge1)
{
result = node2.pt.X > node1.pt.X;
return node2.edge1->dx > 0 ? !result : result;
}
else if (node1.ed... | movq 0x18(%rsi), %rax
cmpq %rax, 0x18(%rdi)
jne 0x509f85
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
je 0x509f89
movq 0x8(%rdi), %rdx
cmpq %rcx, %rdx
je 0x509f89
movq 0x8(%rsi), %r8
movq 0x10(%rsi), %rcx
cmpq %r8, %rax
setne %sil
cmpq %r8, %rdx
setne %r9b
movq 0x10(%rdi), %rdx
cmpq %rdx, %rcx
setg %al
testb %r9... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::SwapIntersectNodes(ClipperLib::IntersectNode&, ClipperLib::IntersectNode&) | void SwapIntersectNodes(IntersectNode &int1, IntersectNode &int2)
{
TEdge *e1 = int1.edge1;
TEdge *e2 = int1.edge2;
IntPoint p = int1.pt;
int1.edge1 = int2.edge1;
int1.edge2 = int2.edge2;
int1.pt = int2.pt;
int2.edge1 = e1;
int2.edge2 = e2;
int2.pt = p;
} | movups 0x10(%rdi), %xmm0
movaps %xmm0, -0x18(%rsp)
movq (%rsi), %rax
movups (%rdi), %xmm0
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rsi)
movaps -0x18(%rsp), %xmm0
movups %xmm0, 0x10(%rsi)
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::GetUnitNormal(ClipperLib::IntPoint const&, ClipperLib::IntPoint const&) | DoublePoint GetUnitNormal( const IntPoint &pt1, const IntPoint &pt2)
{
if(pt2.X == pt1.X && pt2.Y == pt1.Y)
return DoublePoint(0, 0);
double dx = (double)(pt2.X - pt1.X);
double dy = (double)(pt2.Y - pt1.Y);
double f = 1 *1.0/ std::sqrt( dx*dx + dy*dy );
dx *= f;
dy *= f;
return DoublePoint(dy, -dx)... | movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq %rcx, %rdi
xorq %rsi, %rdi
movq %rax, %r8
xorq %rdx, %r8
xorpd %xmm1, %xmm1
orq %rdi, %r8
xorpd %xmm0, %xmm0
je 0x50a53e
subq %rsi, %rcx
cvtsi2sd %rcx, %xmm2
subq %rdx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movapd %xmm0, %xmm1
mul... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::operator<<(std::ostream&, ClipperLib::IntPoint&) | std::ostream& operator <<(std::ostream &s, IntPoint& p)
{
s << p.X << ' ' << p.Y << "\n";
return s;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x1a65e0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1a61e0
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x1a65e0
leaq 0x9fc52(%rip), %rsi # 0x5aa444
movl $0x1, %edx
movq %rax, %rdi
callq 0x1a6... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::Int128::operator*(ClipperLib::Int128 const&) const | Int128 operator * (const Int128 &rhs) const
{
if ( !(hi == 0 || hi == -1) || !(rhs.hi == 0 || rhs.hi == -1))
throw "Int128 operator*: overflow error";
bool negate = (hi < 0) != (rhs.hi < 0);
Int128 tmp(*this);
if (tmp.hi < 0) Negate(tmp);
ulong64 int1Hi = ulong64(tmp.lo) >> 32... | movq (%rsi), %rcx
leaq 0x1(%rcx), %rax
cmpq $0x1, %rax
ja 0x50a99f
movq (%rdx), %rax
leaq 0x1(%rax), %r8
cmpq $0x2, %r8
jae 0x50a99f
xorq %rcx, %rax
movq 0x8(%rsi), %rsi
movq %rsi, %r8
negq %r8
testq %rcx, %rcx
cmovnsq %rsi, %r8
movq %r8, %rsi
shrq $0x20, %rsi
movups (%rdx), %xmm0
movups %xmm0, (%rdi)
movq 0x8(%rdi), %... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ClipperLib::PolyOffsetBuilder::DoSquare(double) | void DoSquare(double mul = 1.0)
{
IntPoint pt1 = IntPoint((long64)Round(m_p[m_i][m_j].X + normals[m_k].X * m_delta),
(long64)Round(m_p[m_i][m_j].Y + normals[m_k].Y * m_delta));
IntPoint pt2 = IntPoint((long64)Round(m_p[m_i][m_j].X + normals[m_j].X * m_delta),
(long64)Round(m_p[m_i][m_j].Y + norm... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rax
leaq (%rax,%rax,2), %rdx
movq 0x58(%rdi), %rax
movq (%rdi), %rsi
movq 0x20(%rdi), %rcx
movq (%rsi,%rdx,8), %rdx
shlq $0x4, %rax
cvtsi2sdq (%rdx,%rax), %xmm7
movq 0x60(%rdi), %rsi
shlq $0x4, %rsi
movsd (%rcx,%rsi), %xmm1
movsd 0x8(%r... | /hbina[P]fatuous/thirdparty/assimp/contrib/clipper/clipper.cpp |
ODDLParser::OpenDDLParser::~OpenDDLParser() | OpenDDLParser::~OpenDDLParser() {
clear();
} | pushq %rbx
movq %rdi, %rbx
callq 0x50da12
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x50d9f2
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x50da08
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x1a5190
popq %rbx
retq
movq %rax, %rdi
callq 0x1d8731
| /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLParser.cpp |
ODDLParser::OpenDDLParser::setLogCallback(void (*)(ODDLParser::LogSeverity, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)) | void OpenDDLParser::setLogCallback( logCallback callback ) {
if( ddl_nullptr != callback ) {
// install user-specific log callback
m_logCallback = callback;
} else {
// install default log callback
m_logCallback = &logMessage;
}
} | testq %rsi, %rsi
leaq -0x1de(%rip), %rax # 0x50d87e
cmovneq %rsi, %rax
movq %rax, (%rdi)
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLParser.cpp |
ODDLParser::OpenDDLParser::parseHeader(char*, char*) | char *OpenDDLParser::parseHeader( char *in, char *end ) {
if( ddl_nullptr == in || in == end ) {
return in;
}
Text *id( ddl_nullptr );
in = OpenDDLParser::parseIdentifier( in, end, &id );
#ifdef DEBUG_HEADER_NAME
dumpId( id );
#endif // DEBUG_HEADER_NAME
in = lookForNextToken( in, end... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
testq %rsi, %rsi
sete %al
cmpq %rdx, %rsi
sete %cl
orb %al, %cl
jne 0x50e1fc
movq %rdx, %r15
movq %rdi, %r12
leaq 0x60(%rsp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x50e440
movq %rax, %rbx
movabsq $... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLParser.cpp |
ODDLParser::OpenDDLParser::parseStructure(char*, char*) | char *OpenDDLParser::parseStructure( char *in, char *end ) {
if( ddl_nullptr == in || in == end ) {
return in;
}
bool error( false );
in = lookForNextToken( in, end );
if( *in == *Grammar::OpenBracketToken) {
// loop over all children ( data and nodes )
do {
in =... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rax
testq %rsi, %rsi
sete %cl
cmpq %rdx, %rsi
sete %dl
orb %cl, %dl
jne 0x50e411
movq %rdi, %rbx
movb $0x0, 0x7(%rsp)
movabsq $0x100100002600, %r12 # imm = 0x100100002600
movzbl (%rax), %ecx
cmpq $0x2c, %rcx
ja 0x50e368
btq %rcx,... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLParser.cpp |
ODDLParser::OpenDDLParser::parseStructureBody(char*, char*, bool&) | char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
if( !isNumeric( *in ) && !isCharacter( *in ) ) {
++in;
}
in = lookForNextToken( in, end );
Value::ValueType type( Value::ddl_none );
size_t arrayLen( 0 );
in = OpenDDLParser::parsePrimitiveDataType( in, end, t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
movb (%rsi), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
setb %cl
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
setb %al
andb %cl, %al
movzbl %al, %edi
addq %rsi, %rdi
movabsq $0x100100... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLParser.cpp |
ODDLParser::OpenDDLParser::parseDataArrayList(char*, char*, ODDLParser::Value::ValueType, ODDLParser::DataArrayList**) | char *OpenDDLParser::parseDataArrayList( char *in, char *end,Value::ValueType type,
DataArrayList **dataArrayList ) {
if ( ddl_nullptr == dataArrayList ) {
return in;
}
*dataArrayList = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
testq %rcx, %rcx
je 0x50f4e0
movl %edx, %ebp
movq %rsi, %r14
movq $0x0, (%rcx)
testq %rbx, %rbx
sete %al
cmpq %rsi, %rbx
sete %dl
orb %al, %dl
jne 0x50f4e0
movabsq $0x100100002600, %r13 # imm = 0x100100002600
movzbl (%r... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLParser.cpp |
ODDLParser::OpenDDLParser::parseReference(char*, char*, std::vector<ODDLParser::Name*, std::allocator<ODDLParser::Name*>>&) | char *OpenDDLParser::parseReference( char *in, char *end, std::vector<Name*> &names ) {
if( ddl_nullptr == in || in == end ) {
return in;
}
Name *nextName( ddl_nullptr );
in = parseName( in, end, &nextName );
if( nextName ) {
names.push_back( nextName );
}
while( Grammar::Co... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
cmpq %rsi, %rdi
sete %cl
orb %al, %cl
jne 0x50f640
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movq %rbx, %rdi
movq %r12, %rdx
callq 0x50e556
movq %rax, %rbx
movq (%r12), %rax
testq %rax, %r... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLParser.cpp |
ODDLParser::Text::set(char const*, unsigned long) | void Text::set( const char *buffer, size_t numChars ) {
clear();
if( numChars > 0 ) {
m_len = numChars;
m_capacity = m_len + 1;
m_buffer = new char[ m_capacity ];
strncpy( m_buffer, buffer, numChars );
m_buffer[ numChars ] = '\0';
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x510733
callq 0x1a5610
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testq %rbx, %rbx
je 0x510771
movq %rbx, 0x8(%r15)
leaq 0x1(%rbx), %rdi
movq %rdi, (%r15)
... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp |
ODDLParser::Value::getFloat() const | float Value::getFloat() const {
if( m_type == ddl_float ) {
float v;
::memcpy( &v, m_data, m_size );
return ( float ) v;
} else {
float tmp;
::memcpy( &tmp, m_data, 4 );
return ( float ) tmp;
}
} | cmpl $0xa, (%rdi)
jne 0x511cf3
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a5110
movss (%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x10(%rdi), %rax
movss (%rax), %xmm0
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/Value.cpp |
ODDLParser::Value::getDouble() const | double Value::getDouble() const {
if ( m_type == ddl_double ) {
double v;
::memcpy( &v, m_data, m_size );
return ( float ) v;
}
else {
double tmp;
::memcpy( &tmp, m_data, 4 );
return ( double ) tmp;
}
} | cmpl $0xb, (%rdi)
jne 0x511d65
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1a5110
cvtsd2ss (%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x10(%rdi), %rax
movl (%rax), %eax
movq %rax, %xmm0
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/Value.cpp |
ODDLParser::Value::setRef(ODDLParser::Reference*) | void Value::setRef( Reference *ref ) {
assert( ddl_ref == m_type );
if ( ddl_nullptr != ref ) {
const size_t sizeInBytes( ref->sizeInBytes() );
if ( sizeInBytes > 0 ) {
if ( ddl_nullptr != m_data ) {
delete [] m_data;
}
m_data = (unsigned cha... | pushq %r15
pushq %r14
pushq %rbx
cmpl $0xd, (%rdi)
jne 0x511e40
movq %rsi, %r14
testq %rsi, %rsi
je 0x511e3a
movq %rdi, %rbx
movq %r14, %rdi
callq 0x510a12
testq %rax, %rax
je 0x511e3a
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x511e1e
callq 0x1a5610
movl $0x10, %edi
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
movq ... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/Value.cpp |
ODDLParser::ValueAllocator::allocPrimData(ODDLParser::Value::ValueType, unsigned long) | Value *ValueAllocator::allocPrimData( Value::ValueType type, size_t len ) {
if( type == Value::ddl_none || Value::ddl_types_max == type ) {
return ddl_nullptr;
}
Value *data = new Value( type );
switch( type ) {
case Value::ddl_bool:
data->m_size = sizeof( bool );
... | pushq %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpl $-0x1, %edi
je 0x512116
movl %edi, %ebp
cmpl $0xe, %edi
je 0x512116
movq %rsi, %r14
movl $0x20, %edi
callq 0x1a5230
movq %rax, %rbx
movl %ebp, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
cmpl $0xc, %ebp
ja 0x512116
addq $0x8, %rax
movl %e... | /hbina[P]fatuous/thirdparty/assimp/contrib/openddlparser/code/Value.cpp |
o3dgc::Arithmetic_Codec::get_bits(unsigned int) | unsigned Arithmetic_Codec::get_bits(unsigned bits)
{
#ifdef _DEBUG
if (mode != 2) AC_Error("decoder not initialized");
if ((bits < 1) || (bits > 20)) AC_Error("invalid number of bits");
#endif
unsigned s = value / (length >>= bits); // decode symbol, change length
value -= len... | movl %esi, %ecx
movl 0x1c(%rdi), %eax
movl 0x20(%rdi), %esi
shrl %cl, %esi
movl %esi, 0x20(%rdi)
xorl %edx, %edx
divl %esi
movl %edx, 0x1c(%rdi)
cmpl $0xffffff, %esi # imm = 0xFFFFFF
ja 0x51249b
movq 0x10(%rdi), %rcx
incq %rcx
movl %esi, %r8d
shll $0x8, %edx
movq %rcx, 0x10(%rdi)
movzbl (%rcx), %r9d
orl %r9d, %... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp |
o3dgc::Arithmetic_Codec::decode(o3dgc::Adaptive_Bit_Model&) | unsigned Arithmetic_Codec::decode(Adaptive_Bit_Model & M)
{
#ifdef _DEBUG
if (mode != 2) AC_Error("decoder not initialized");
#endif
unsigned x = M.bit_0_prob * (length >> BM__LengthShift); // product l x p0
unsigned bit = (value >= x); // decision
... | pushq %rbp
pushq %rbx
pushq %rax
movl 0x1c(%rdi), %ebx
movl 0x20(%rdi), %eax
movl %eax, %ebp
shrl $0xd, %ebp
imull 0x8(%rsi), %ebp
movl %ebx, %ecx
subl %ebp, %ecx
jb 0x51268a
movl %ecx, 0x1c(%rdi)
subl %ebp, %eax
movl %eax, 0x20(%rdi)
jmp 0x512693
movl %ebp, 0x20(%rdi)
incl 0xc(%rsi)
movl 0x20(%rdi), %eax
cmpl $0xfffff... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp |
o3dgc::Arithmetic_Codec::set_buffer(unsigned int, unsigned char*) | void Arithmetic_Codec::set_buffer(unsigned max_code_bytes,
unsigned char * user_buffer)
{
// test for reasonable sizes
if (!max_code_bytes)// || (max_code_bytes > 0x10000000U)) // updated by K. Mammou
{
A... | pushq %rbx
testl %esi, %esi
je 0x512c94
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
jne 0x512ca0
testq %rdx, %rdx
je 0x512c67
movl %esi, 0x24(%rbx)
movq %rdx, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x512c5d
callq 0x1a5610
movq $0x0, 0x8(%rbx)
jmp 0x512c92
cmpl %esi, 0x24(%rbx)
jae 0x512c92
movl %esi, 0x24(%rbx)
movq... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp |
o3dgc::Arithmetic_Codec::write_to_file(_IO_FILE*) | unsigned Arithmetic_Codec::write_to_file(FILE * code_file)
{
unsigned header_bytes = 0, code_bytes = stop_encoder(), nb = code_bytes;
// write variable-length header with number of code bytes
do {
int file_byte = int(nb & 0x7FU);
if ((nb >>= 7) > 0) file_byte |=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x512e14
movl %eax, %r15d
movl $0x80, %r12d
movl %eax, %ebp
movl %eax, %r13d
movl %r13d, %eax
andl $0x7f, %eax
movl %eax, %edi
orl %r12d, %edi
cmpl %r12d, %r13d
cmovbl %eax, %edi
movq %rbx, %rsi
callq 0x1a... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp |
o3dgc::Static_Data_Model::set_distribution(unsigned int, double const*) | void Static_Data_Model::set_distribution(unsigned number_of_symbols,
const double probability[])
{
if ((number_of_symbols < 2) || (number_of_symbols > (1 << 11)))
AC_Error("invalid number of data symbols");
if (data_symbols != number_of_symbols) { ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
leal -0x801(%r15), %eax
cmpl $0xfffff800, %eax # imm = 0xFFFFF800
jbe 0x5131a5
movq %rdx, %r14
movq %rdi, %rbx
cmpl %r15d, 0x10(%rdi)
je 0x51309f
movl %r15d, 0x10(%rbx)
leal -0x1(%r15), %eax
movl %eax, 0x14(%rbx)
movq (%rbx), %rdi
testq %rdi,... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp |
o3dgc::Adaptive_Data_Model::set_alphabet(unsigned int) | void Adaptive_Data_Model::set_alphabet(unsigned number_of_symbols)
{
if ((number_of_symbols < 2) || (number_of_symbols > (1 << 11)))
AC_Error("invalid number of data symbols");
if (data_symbols != number_of_symbols) { // assign memory for data model
data_symbols = number_of_symbols;... | pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
leal -0x801(%r14), %eax
cmpl $0xfffff800, %eax # imm = 0xFFFFF800
jbe 0x5132a6
movq %rdi, %rbx
cmpl %r14d, 0x24(%rdi)
je 0x513299
movl %r14d, 0x24(%rbx)
leal -0x1(%r14), %eax
movl %eax, 0x28(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x513225
callq 0x1a5610
movl ... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp |
o3dgc::Adaptive_Data_Model::reset() | void Adaptive_Data_Model::reset(void)
{
if (data_symbols == 0) return;
// restore probability estimates to uniform distribution
total_count = 0;
update_cycle = data_symbols;
for (unsigned k = 0; k < data_symbols; k++) symbol_count[k] = 1;
update(false);
... | movl 0x24(%rdi), %eax
testl %eax, %eax
je 0x513306
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x18(%rdi)
movl %eax, 0x1c(%rdi)
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movl $0x1, (%rcx,%rax,4)
incq %rax
movl 0x24(%rbx), %ecx
cmpq %rcx, %rax
jb 0x5132d7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x51295c
movl 0x24(%rbx), %eax
addl $0... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcArithmeticCodec.cpp |
o3dgc::SaveUIntData(o3dgc::Vector<long> const&, o3dgc::BinaryStream&) | O3DGCErrorCode SaveUIntData(const Vector<long> & data,
BinaryStream & bstream)
{
unsigned long start = bstream.GetSize();
bstream.WriteUInt32ASCII(0);
const unsigned long size = data.GetSize();
bstream.WriteUInt32ASCII(size);
for(u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
movl $0x5, %r14d
leaq 0xe(%rsp), %r12
movb $0x0, 0xe(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5145a8
decq %r14
jne 0x513330
movq 0x10(%r15), %r14
movl $0x5,... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcTriangleFans.cpp |
o3dgc::LoadIntACEGC(o3dgc::Vector<long>&, unsigned long, o3dgc::BinaryStream const&, unsigned long&) | O3DGCErrorCode LoadIntACEGC(Vector<long> & data,
const unsigned long M,
const BinaryStream & bstream,
unsigned long & iterator)
{
unsigned long sizeSize = bstream.ReadUInt32Bin(iterator) - 12;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x4d5326
movq %rax, %r12
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4d5326
testq %rax, %rax
je 0x51400f
movq %rax, %r15
leaq -0xc(%r12), %... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcTriangleFans.cpp |
o3dgc::CompressedTriangleFans::Load(o3dgc::BinaryStream const&, unsigned long&, bool, o3dgc::O3DGCStreamType) | O3DGCErrorCode CompressedTriangleFans::Load(const BinaryStream & bstream,
unsigned long & iterator,
bool decodeTrianglesOrder,
O3DGCStreamType streamType)
{
#... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %r12
leaq 0x30(%rdi), %rbp
leaq 0x48(%rdi), %r13
leaq 0x60(%rdi), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, %r8d
jne 0x5141dd
movq %r15, %rdi
movq %r14, %r... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcTriangleFans.cpp |
o3dgc::Vector<long>::PushBack(long const&) | void PushBack(const T & value)
{
if (m_size == m_allocated)
{
m_allocated *= 2;
if (m_allocated < O3DGC_DEFAULT_VECTO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rbp
movq 0x10(%rdi), %r13
cmpq %rbp, %r13
jne 0x514562
leaq (,%r13,2), %rax
cmpq $0x21, %rax
movl $0x20, %ebp
cmovaeq %rax, %rbp
movq %rbp, 0x8(%rbx)
shrq $0x3d, %rax
leaq (,%rbp,8), %rcx
xorl %... | /hbina[P]fatuous/thirdparty/assimp/contrib/Open3DGC/o3dgcVector.h |
Assimp::IOSystem2Unzip::seek(void*, void*, unsigned long, int) | long IOSystem2Unzip::seek(voidpf /*opaque*/, voidpf stream, uLong offset, int origin) {
IOStream* io_stream = (IOStream*)stream;
aiOrigin assimp_origin;
switch (origin) {
default:
case ZLIB_FILEFUNC_SEEK_CUR:
assimp_origin = aiOrigin_CUR;
break;
c... | pushq %rax
movq %rsi, %rdi
xorl %eax, %eax
cmpl $0x2, %ecx
sete %al
incl %eax
testl %ecx, %ecx
cmovel %ecx, %eax
movq (%rsi), %rcx
movq %rdx, %rsi
movl %eax, %edx
callq *0x20(%rcx)
xorl %ecx, %ecx
negl %eax
sbbq %rcx, %rcx
movq %rcx, %rax
popq %rcx
retq
| /hbina[P]fatuous/thirdparty/assimp/code/Common/ZipArchiveIOSystem.cpp |
Assimp::ZipFileInfo::Extract(void*) const | ZipFile * ZipFileInfo::Extract(unzFile zip_handle) const {
// Find in the ZIP. This cannot fail
unz_file_pos_s *filepos = const_cast<unz_file_pos_s*>(&(m_ZipFilePos));
if (unzGoToFilePos(zip_handle, filepos) != UNZ_OK)
return nullptr;
if (unzOpenCurrentFile(zip_handle) != UN... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %rsi
movq %rbx, %rdi
callq 0x1a5ab0
testl %eax, %eax
jne 0x5148eb
movq %rbx, %rdi
callq 0x1a6500
testl %eax, %eax
je 0x5148f7
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x20, %edi
callq 0x23a13c
movq %rax, %... | /hbina[P]fatuous/thirdparty/assimp/code/Common/ZipArchiveIOSystem.cpp |
Assimp::ZipArchiveIOSystem::Implement::~Implement() | ZipArchiveIOSystem::Implement::~Implement() {
m_ArchiveMap.clear();
if (m_ZipFileHandle != nullptr) {
unzClose(m_ZipFileHandle);
m_ZipFileHandle = nullptr;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x5154e8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x514c49
callq 0x1a5280
movq $0x0, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x515470
movq %rax, %rdi
callq 0x1d8731
| /hbina[P]fatuous/thirdparty/assimp/code/Common/ZipArchiveIOSystem.cpp |
Assimp::ZipArchiveIOSystem::Implement::OpenFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | IOStream * ZipArchiveIOSystem::Implement::OpenFile(std::string& filename) {
MapArchive();
SimplifyFilename(filename);
// Find in the map
ZipFileInfoMap::const_iterator zip_it = m_ArchiveMap.find(filename);
if (zip_it == m_ArchiveMap.cend())
return nullptr;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x514c60
movq %r14, %rdi
callq 0x514d94
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x515724
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x515094
addq $0x40, %rax
movq (%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5148c4
xorl %e... | /hbina[P]fatuous/thirdparty/assimp/code/Common/ZipArchiveIOSystem.cpp |
Assimp::VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace*, unsigned int, unsigned int, bool) | VertexTriangleAdjacency::VertexTriangleAdjacency(aiFace *pcFaces,
unsigned int iNumFaces,
unsigned int iNumVertices /*= 0*/,
bool bComputeNumTriangles /*= false*/)
{
// compute the number of referenced vertices if it wasn't specified by the caller
const aiFace* const pcFaceEnd = pcFaces + iNumFaces;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movl %edx, %ebp
shlq $0x4, %rbp
addq %rsi, %rbp
testl %ecx, %ecx
jne 0x51633d
cmpl $0x0, 0x4(%rsp)
je 0x51633a
xorl %r12d, %r12d
movq %r14, %rax
testq %rax, %rax
je 0x5164c0... | /hbina[P]fatuous/thirdparty/assimp/code/Common/VertexTriangleAdjacency.cpp |
Assimp::SceneCombiner::MergeScenes(aiScene**, std::vector<aiScene*, std::allocator<aiScene*>>&, unsigned int) | void SceneCombiner::MergeScenes(aiScene** _dest,std::vector<aiScene*>& src, unsigned int flags) {
if ( nullptr == _dest ) {
return;
}
// if _dest points to NULL allocate a new scene. Otherwise clear the old and reuse it
if (src.empty()) {
if (*_dest) {
(*_dest)->~aiScene();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x516bfd
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rdi), %rdi
cmpq 0x8(%rsi), %rax
je 0x516ad9
movl %edx, %ebp
testq %rdi, %rdi
je 0x516b01
callq 0x240838
jmp 0x516b19
testq %rdi, %rdi
je 0x516bf7
callq 0x240838
m... | /hbina[P]fatuous/thirdparty/assimp/code/Common/SceneCombiner.cpp |
Assimp::SceneCombiner::Copy(aiMaterial**, aiMaterial const*) | void SceneCombiner::Copy (aiMaterial** _dest, const aiMaterial* src) {
if ( nullptr == _dest || nullptr == src ) {
return;
}
aiMaterial* dest = (aiMaterial*) ( *_dest = new aiMaterial() );
dest->Clear();
delete[] dest->mProperties;
dest->mNumAllocated = src->mNumAllocated;
dest-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x518610
movq %rsi, %rbx
movq %rdi, %r15
movl $0x10, %edi
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x2466d0
movq %r14, (%r15)
movq %r14, %rdi
callq 0x246712
movq ... | /hbina[P]fatuous/thirdparty/assimp/code/Common/SceneCombiner.cpp |
Assimp::SceneCombiner::CopyScene(aiScene**, aiScene const*, bool) | void SceneCombiner::CopyScene(aiScene** _dest,const aiScene* src,bool allocate) {
if ( nullptr == _dest || nullptr == src ) {
return;
}
if (allocate) {
*_dest = new aiScene();
}
aiScene* dest = *_dest;
ai_assert(nullptr != dest);
// copy metadata
if ( nullptr != src->mM... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x519feb
movq %rsi, %rbx
movq %rdi, %r15
testb %dl, %dl
je 0x519d9f
movl $0x80, %edi
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x2407d2
movq %r14, (%r15)
jmp 0x519... | /hbina[P]fatuous/thirdparty/assimp/code/Common/SceneCombiner.cpp |
Assimp::SceneCombiner::Copy(aiMetadata**, aiMetadata const*) | void SceneCombiner::Copy(aiMetadata** _dest, const aiMetadata* src) {
if ( nullptr == _dest || nullptr == src ) {
return;
}
if ( 0 == src->mNumProperties ) {
return;
}
aiMetadata* dest = *_dest = aiMetadata::Alloc( src->mNumProperties );
std::copy(src->mKeys, src->mKeys + src->... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x51a8a6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl (%rsi), %r13d
testq %r13, %r13
je 0x51a898
movq %rdi, %r12
movl $0x18, %edi
callq 0x1a5230
movq %rax, 0x8(%rsp)
movl %r13d, (%rax)
movq %r... | /hbina[P]fatuous/thirdparty/assimp/code/Common/SceneCombiner.cpp |
Assimp::SkeletonMeshBuilder::CreateMaterial() | aiMaterial* SkeletonMeshBuilder::CreateMaterial()
{
aiMaterial* matHelper = new aiMaterial;
// Name
aiString matName( std::string( "SkeletonMaterial"));
matHelper->AddProperty( &matName, AI_MATKEY_NAME);
// Prevent backface culling
const int no_cull = 1;
matHelper->AddProperty(&no_cull,1,A... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movl $0x10, %edi
callq 0x1a5230
movq %rax, %rbx
movq %rax, %rdi
callq 0x2466d0
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xbea86(%rip), %rsi # 0x5db870
leaq 0xbea8f(%rip), %rdx # 0x5db880
leaq 0x10(%rsp), %r15
movq %r... | /hbina[P]fatuous/thirdparty/assimp/code/Common/SkeletonMeshBuilder.cpp |
Assimp::StandardShapes::MakeMesh(unsigned int (*)(std::vector<aiVector3t<float>, std::allocator<aiVector3t<float>>>&, bool)) | aiMesh* StandardShapes::MakeMesh ( unsigned int (*GenerateFunc)(
std::vector<aiVector3D>&, bool))
{
std::vector<aiVector3D> temp;
unsigned num = (*GenerateFunc)(temp,true);
return MakeMesh(temp,num);
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rax
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x1, %esi
callq *%rax
movq %rsp, %rdi
movl %eax, %esi
callq 0x51d44c
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x51d73b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %r... | /hbina[P]fatuous/thirdparty/assimp/code/Common/StandardShapes.cpp |
Assimp::StandardShapes::MakeOctahedron(std::vector<aiVector3t<float>, std::allocator<aiVector3t<float>>>&) | unsigned int StandardShapes::MakeOctahedron(std::vector<aiVector3D>& positions)
{
positions.reserve(positions.size()+24);
const aiVector3D v0 = aiVector3D(1.0, 0.0, 0.0) ;
const aiVector3D v1 = aiVector3D(-1.0, 0.0, 0.0);
const aiVector3D v2 = aiVector3D(0.0, 1.0, 0.0);
const aiVector3D v3 = ai... | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
addq $0x18, %rsi
callq 0x27a0be
movss 0x3aad2(%rip), %xmm0 # 0x55b5b0
movlps %xmm0, 0x50(%rsp)
xorl %eax, %eax
movl %eax, 0x58(%rsp)
movss ... | /hbina[P]fatuous/thirdparty/assimp/code/Common/StandardShapes.cpp |
Assimp::StandardShapes::MakeHexahedron(std::vector<aiVector3t<float>, std::allocator<aiVector3t<float>>>&, bool) | unsigned int StandardShapes::MakeHexahedron(std::vector<aiVector3D>& positions,
bool polygons /*= false*/)
{
positions.reserve(positions.size()+36);
const ai_real length = ai_real(1.0)/ai_real(1.73205080);
const aiVector3D v0 = aiVector3D(-1.0,-1.0,-1.0)*length;
const aiVector3D v1 = aiVector3D(1... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
addq $0x24, %rsi
callq 0x27a0be
movsd 0xba602(%rip), %xmm0 # 0x5db930
movsd %xmm... | /hbina[P]fatuous/thirdparty/assimp/code/Common/StandardShapes.cpp |
CatmullClarkSubdivider::Subdivide(aiMesh**, unsigned long, aiMesh**, unsigned int, bool) | void CatmullClarkSubdivider::Subdivide (
aiMesh** smesh,
size_t nmesh,
aiMesh** out,
unsigned int num,
bool discard_input
)
{
ai_assert( NULL != smesh );
ai_assert( NULL != out );
// course, both regions may not overlap
ai_assert(smesh<out || smesh+nmesh>out+nmesh);
if (!num... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, 0x4(%rsp)
testq %rsi, %rsi
je 0x522e11
movq %rcx, %r12
testq %rcx, %rcx
je 0x522e30
movq %rsi, %r14
cmpq %r12, %rsi
je 0x522e4f
movq %rdx, %rbx
testl %r8d, %r8d
je 0x522d19
movq %rdi, 0x70(%rsp)
movl %r8d, 0x2c(%rsp)
xorps %xm... | /hbina[P]fatuous/thirdparty/assimp/code/Common/Subdivision.cpp |
AddLineNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string AddLineNumber(const std::string& s,uint64_t line /*= LINE_NOT_SPECIFIED*/, const std::string& prefix = "")
{
return line == STEP::SyntaxError::LINE_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(line ",line,") ",s) );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
cmpq $-0x1, %rdx
je 0x52528c
movq %rdx, %r15
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x1a6170
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x1a61e0
leaq 0x... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/STEPParser/STEPFileReader.cpp |
AddEntityID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string AddEntityID(const std::string& s,uint64_t entity /*= ENTITY_NOT_SPECIFIED*/, const std::string& prefix = "")
{
return entity == STEP::TypeError::ENTITY_NOT_SPECIFIED ? prefix+s : static_cast<std::string>( (Formatter::format(),prefix,"(entity #",entity,") ",s));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
cmpq $-0x1, %rdx
je 0x52538c
movq %rdx, %r15
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x1a6170
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x1a61e0
leaq 0x... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/STEPParser/STEPFileReader.cpp |
Assimp::STEP::ReadFile(Assimp::STEP::DB&, Assimp::STEP::EXPRESS::ConversionSchema const&, char const* const*, unsigned long, char const* const*, unsigned long) | void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
const char* const* types_to_track, size_t len,
const char* const* inverse_indices_to_track, size_t len2)
{
db.SetSchema(scheme);
db.SetTypesToTrack(types_to_track,len);
db.SetInverseIndicesToTrack(inverse_indices_to_track,len2);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %r9, %r14
movq %r8, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, 0x170(%rdi)
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x527e18
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x527f66
leaq 0x130(%rbx)... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/STEPParser/STEPFileReader.cpp |
Assimp::STEP::LazyObject::LazyObject(Assimp::STEP::DB&, unsigned long, unsigned long, char const*, char const*) | STEP::LazyObject::LazyObject(DB& db, uint64_t id,uint64_t /*line*/, const char* const type,const char* args)
: id(id)
, type(type)
, db(db)
, args(args)
, obj() {
// find any external references and store them in the database.
// this helps us emulate STEPs INVERSE fields.
if (!db.KeepInverseIndicesForType(... | movq %rdx, (%rdi)
movq %r8, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movq %r9, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq 0x100(%rsi), %rax
testq %rax, %rax
je 0x5278bb
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movq %rdx, %rbx
movq %rsi, %r15
leaq 0xf8(%rsi), %rdx
movq %rdx, %rcx
xorl %es... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/STEPParser/STEPFileReader.cpp |
Assimp::STEP::DB::DB(std::shared_ptr<Assimp::StreamReader<false, false>>) | DB(std::shared_ptr<StreamReaderLE> reader)
: reader(reader)
, splitter(*reader,true,true)
, evaluated_count()
, schema( nullptr )
{} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi... | /hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h |
Assimp::STEP::DB::SetTypesToTrack(char const* const*, unsigned long) | void SetTypesToTrack(const char* const* types, size_t N) {
for(size_t i = 0; i < N;++i) {
objects_bytype[types[i]] = ObjectSet();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
testq %rdx, %rdx
je 0x527f21
movq %rdi, %r15
leaq 0x18(%rsp), %rbp
addq $0x90, %r15
xorl %r14d, %r14d
leaq 0x58(%rsp), %r12
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14... | /hbina[P]fatuous/thirdparty/assimp/./code/Step/STEPFile.h |
Assimp::Discreet3DSImporter::MakeUnique(Assimp::D3DS::Mesh&) | void Discreet3DSImporter::MakeUnique(D3DS::Mesh& sMesh)
{
// TODO: really necessary? I don't think. Just a waste of memory and time
// to do it now in a separate buffer.
// Allocate output storage
std::vector<aiVector3D> vNew (sMesh.mFaces.size() * 3);
std::vector<aiVector3D> vNew2;
if (sMesh.... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq 0x20(%rsi), %rax
subq 0x18(%rsi), %rax
sarq $0x4, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x18(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rdx
callq 0x267026
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x70(%rbx), %rax
cmpq 0x68(%rbx),... | /hbina[P]fatuous/thirdparty/assimp/code/3DS/3DSConverter.cpp |
CountTracks(Assimp::D3DS::Node*, unsigned int&) | void CountTracks(D3DS::Node* node, unsigned int& cnt)
{
//////////////////////////////////////////////////////////////////////////////
// We will never generate more than one channel for a node, so
// this is rather easy here.
if (node->aPositionKeys.size() > 1 || node->aRotationKeys.size() > 1 |... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x90(%rdi), %rcx
subq 0x88(%rdi), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x1, %rcx
ja 0x52c1fc
movq 0x78(%r14), %rcx
subq 0x70(%r14), %rcx
sarq $0x3, %rcx
imulq %rax, %rcx
cmpq $0x1, ... | /hbina[P]fatuous/thirdparty/assimp/code/3DS/3DSConverter.cpp |
Assimp::Discreet3DSImporter::GenerateNodeGraph(aiScene*) | void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
{
pcOut->mRootNode = new aiNode();
if (0 == mRootNode->mChildren.size())
{
//////////////////////////////////////////////////////////////////////////////
// It seems the file is so messed up that it has not even a hierarchy.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2402f8
movq %r15, 0x8(%rbx)
movq 0x90(%r13), %rdi
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
movq %r13, (%r... | /hbina[P]fatuous/thirdparty/assimp/code/3DS/3DSConverter.cpp |
Assimp::LWO::AnimResolver::ExtractBindPose(aiMatrix4x4t<float>&) | void AnimResolver::ExtractBindPose(aiMatrix4x4& out)
{
// If we have no envelopes, return identity
if (envelopes.empty()) {
out = aiMatrix4x4();
return;
}
aiVector3D angles, scaling(1.f,1.f,1.f), translation;
if (trans_x) translation.x = trans_x->keys[0].value;
if (trans_y) tran... | pushq %rbx
subq $0xe0, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
cmpq %rax, (%rax)
je 0x52db83
movq 0x10(%rdi), %rax
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testq %rax, %rax
je 0x52d2c1
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x52d2d8
movq 0x10(%rax), %... | /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOAnimation.cpp |
Assimp::LWOImporter::LoadLWOBPolygons(unsigned int) | void LWOImporter::LoadLWOBPolygons(unsigned int length)
{
// first find out how many faces and vertices we'll finally need
LE_NCONST uint16_t* const end = (LE_NCONST uint16_t*)(mFileBuffer+length);
LE_NCONST uint16_t* cursor = (LE_NCONST uint16_t*)mFileBuffer;
// perform endianness conversions
#... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0xd8(%rdi), %rax
movl %esi, %ebx
addq %rax, %rbx
testl %esi, %esi
je 0x52f133
testq %rax, %rax
je 0x52f1bc
rolw $0x8, (%rax)
addq $0x2, %rax
cmpq %rbx, %rax
jb 0x52f116
movq 0xd8(%r14), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
lea... | /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOBLoader.cpp |
Assimp::LWOImporter::CountVertsAndFacesLWOB(unsigned int&, unsigned int&, unsigned short*&, unsigned short const*, unsigned int) | void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& faces,
LE_NCONST uint16_t*& cursor, const uint16_t* const end, unsigned int max)
{
while (cursor < end && max--)
{
uint16_t numIndices;
// must have 2 shorts left for numIndices and surface
if (end - cursor <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rcx), %rax
cmpq %r8, %rax
jae 0x52fe23
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
incl %ebx
decl %ebx
je 0x52fe23
movq %r14, %rcx
subq %rax, %rcx
cmpq $0x2, %rcx
jle 0x52fe94
lea... | /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOBLoader.cpp |
Assimp::LWOImporter::CopyFaceIndicesLWOB(__gnu_cxx::__normal_iterator<Assimp::LWO::Face*, std::vector<Assimp::LWO::Face, std::allocator<Assimp::LWO::Face>>>&, unsigned short*&, unsigned short const*, unsigned int) | void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it,
LE_NCONST uint16_t*& cursor,
const uint16_t* const end,
unsigned int max)
{
while (cursor < end && max--)
{
LWO::Face& face = *it;++it;
uint16_t numIndices;
::memcpy(&numIndices, cursor++, 2);
face.mNumIndi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
cmpq %rcx, (%rdx)
jae 0x53009d
movq %rcx, %rbp
movq %rdx, %r15
movq %rdi, %r13
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, 0x8(%rsp)
subl $0x1, %r8d
jb 0x53009d
movq 0x10(%rsp), %rcx
mov... | /hbina[P]fatuous/thirdparty/assimp/code/LWO/LWOBLoader.cpp |
Assimp::ObjFileMtlImporter::createMaterial() | void ObjFileMtlImporter::createMaterial()
{
std::string line( "" );
while( !IsLineEnd( *m_DataIt ) ) {
line += *m_DataIt;
++m_DataIt;
}
std::vector<std::string> token;
const unsigned int numToken = tokenize<std::string>( line, token, " \t" );
std::string name( "" );
if ( num... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7760c(%rip), %rdx # 0x5a8b41
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x209290
movq 0x20(%rbx), %rax
movl $0x3401, %ebp # imm = 0x3401
m... | /hbina[P]fatuous/thirdparty/assimp/code/Obj/ObjFileMtlImporter.cpp |
Assimp::Q3BSPFileParser::getLumps() | void Q3BSPFileParser::getLumps()
{
size_t Offset = m_sOffset;
m_pModel->m_Lumps.resize( kMaxLumps );
for ( size_t idx=0; idx < kMaxLumps; idx++ )
{
sQ3BSPLump *pLump = new sQ3BSPLump;
memcpy( pLump, &m_Data[ Offset ], sizeof( sQ3BSPLump ) );
Offset += sizeof( sQ3BSPLump );
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x20(%rdi), %rdi
addq $0x18, %rdi
movl $0x11, %esi
callq 0x532ae8
xorl %r15d, %r15d
movl $0x8, %edi
callq 0x1a5230
movq 0x8(%rbx), %rcx
addq %r14, %rcx
movq (%rcx,%r15,8), %rcx
movq %rcx, (%rax)
movq 0x20(%rbx), %rcx
movq 0x18(%rcx), %rcx
movq %rax... | /hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileParser.cpp |
Assimp::Q3BSPFileParser::getIndices() | void Q3BSPFileParser::getIndices()
{
ai_assert(nullptr != m_pModel );
sQ3BSPLump *lump = m_pModel->m_Lumps[ kMeshVerts ];
size_t Offset = (size_t) lump->iOffset;
const size_t nIndices = lump->iSize / sizeof( int );
m_pModel->m_Indices.resize( nIndices );
memcpy( &m_pModel->m_Indices[ 0 ], &m_Da... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x5324fc
movq 0x18(%rdi), %rax
movq 0x58(%rax), %r15
movslq (%r15), %r14
movslq 0x4(%r15), %rsi
shrq $0x2, %rsi
addq $0x60, %rdi
callq 0x44c8a6
movq 0x20(%rbx), %rax
movq 0x60(%rax), %rdi
addq 0x8(%rbx), %r14
movslq 0x4(%r15), %r... | /hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileParser.cpp |
Assimp::Q3BSPFileParser::getFaces() | void Q3BSPFileParser::getFaces()
{
ai_assert(nullptr != m_pModel );
size_t Offset = m_pModel->m_Lumps[ kFaces ]->iOffset;
for ( size_t idx = 0; idx < m_pModel->m_Faces.size(); idx++ )
{
sQ3BSPFace *pFace = new sQ3BSPFace;
memcpy( pFace, &m_Data[ Offset ], sizeof( sQ3BSPFace ) );
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x53259f
movq 0x50(%r15), %rax
cmpq 0x48(%r15), %rax
je 0x532595
movq %rdi, %rbx
movq 0x18(%r15), %rax
addq $0x48, %r15
movq 0x68(%rax), %rax
movslq (%rax), %r12
xorl %r13d, %r13d
movl $0x68, %edi
callq 0x1a5230
movq %rax, ... | /hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileParser.cpp |
Assimp::Q3BSPFileParser::getTextures() | void Q3BSPFileParser::getTextures()
{
ai_assert(nullptr != m_pModel );
size_t Offset = m_pModel->m_Lumps[ kTextures ]->iOffset;
for ( size_t idx=0; idx < m_pModel->m_Textures.size(); idx++ )
{
sQ3BSPTexture *pTexture = new sQ3BSPTexture;
memcpy( pTexture, &m_Data[ Offset ], sizeof(sQ3BS... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x532647
movq 0x80(%r15), %rax
cmpq 0x78(%r15), %rax
je 0x53263d
movq %rdi, %rbx
movq 0x18(%r15), %rax
addq $0x78, %r15
movq 0x8(%rax), %rax
movslq (%rax), %r12
xorl %r13d, %r13d
movl $0x48, %edi
callq 0x1a5230
movq %rax, %... | /hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileParser.cpp |
Assimp::Q3BSP::Q3BSPModel::~Q3BSPModel() | ~Q3BSPModel() {
for ( unsigned int i=0; i<m_Lumps.size(); i++ ) {
delete m_Lumps[ i ];
}
for ( unsigned int i=0; i<m_Vertices.size(); i++ ) {
delete m_Vertices[ i ];
}
for ( unsigned int i=0; i<m_Faces.size(); i++ ) {
delete m_Faces[ i ];
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x5328c9
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
movl $0x8, %esi
callq 0x1a5190
movl %ebp, %ecx
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5328... | /hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileData.h |
Assimp::X3DImporter::ParseNode_Geometry2D_ArcClose2D() | void X3DImporter::ParseNode_Geometry2D_ArcClose2D()
{
std::string def, use;
std::string closureType("PIE");
float endAngle = AI_MATH_HALF_PI_F;
float radius = 1;
bool solid = false;
float startAngle = 0;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHEC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x98(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x50(%rsp), %rax
movq %rax, -0x1... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Geometry2D.cpp |
Assimp::X3DImporter::ParseNode_Geometry2D_Circle2D() | void X3DImporter::ParseNode_Geometry2D_Circle2D()
{
std::string def, use;
float radius = 1;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
MACRO_ATTRREAD_LOOPEND;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x50(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movq %rax, 0x18(%rsp)
movq 0x98(%rdi)... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Geometry2D.cpp |
Assimp::X3DImporter::ParseNode_Geometry2D_Polypoint2D() | void X3DImporter::ParseNode_Geometry2D_Polypoint2D()
{
std::string def, use;
std::list<aiVector2D> point;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_REF("point", point, XML_ReadNode_GetAttrVal_AsListVec2f);
MACRO_ATT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r13
leaq 0x68(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x78(%rsp), %rcx
movq %rcx, 0x8(... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Geometry2D.cpp |
Assimp::X3DImporter::ParseNode_Geometry2D_TriangleSet2D() | void X3DImporter::ParseNode_Geometry2D_TriangleSet2D()
{
std::string def, use;
bool solid = false;
std::list<aiVector2D> vertices;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_REF("vertices", vertices, XML_ReadNode_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x68(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x78(%rsp), %rcx
movq %rcx, 0x8(... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Geometry2D.cpp |
Assimp::X3DImporter::ParseNode_Geometry3D_Cylinder() | void X3DImporter::ParseNode_Geometry3D_Cylinder()
{
std::string use, def;
bool bottom = true;
float height = 2;
float radius = 1;
bool side = true;
bool solid = true;
bool top = true;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbp
leaq 0xb0(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x90(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movq %rax, 0x38(%rsp)
movq 0x98(%rdi)... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Geometry3D.cpp |
Assimp::X3DImporter::ParseNode_Geometry3D_IndexedFaceSet() | void X3DImporter::ParseNode_Geometry3D_IndexedFaceSet()
{
std::string use, def;
bool ccw = true;
std::vector<int32_t> colorIndex;
bool colorPerVertex = true;
bool convex = true;
std::vector<int32_t> coordIndex;
float creaseAngle = 0;
std::vector<int32_t> normalIndex;
bool normalPerVe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq %rax, 0xf0(%rsp)
xorps %xmm0, %x... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Geometry3D.cpp |
Assimp::X3DImporter::ParseNode_Rendering_Normal() | void X3DImporter::ParseNode_Rendering_Normal()
{
std::string use, def;
std::list<aiVector3D> vector;
CX3DImporter_NodeElement* ne;
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_REF("vector", vector, XML_ReadNode_GetAttrVal_AsListVec3f);
MACRO_ATTRREAD_LOOPEND;
// if "US... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r12
leaq 0x60(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x70(%rsp), %rcx
movq %rcx, 0x8(... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Rendering.cpp |
Assimp::X3DImporter::ParseNode_Rendering_TriangleFanSet() | void X3DImporter::ParseNode_Rendering_TriangleFanSet()
{
std::string use, def;
bool ccw = true;
bool colorPerVertex = true;
std::vector<int32_t> fanCount;
bool normalPerVertex = true;
bool solid = true;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbp
leaq 0xa8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x88(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movq %rax, 0x70(%rsp)
xorps %xmm0, %x... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Rendering.cpp |
Assimp::X3DImporter::ParseNode_Rendering_TriangleSet() | void X3DImporter::ParseNode_Rendering_TriangleSet()
{
std::string use, def;
bool ccw = true;
bool colorPerVertex = true;
bool normalPerVertex = true;
bool solid = true;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbp
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq %rax, 0x40(%rsp)
movq 0x98(%rdi)... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Rendering.cpp |
glTFCommon::Util::EncodeBase64(unsigned char const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void EncodeBase64(const uint8_t* in, size_t inLength, std::string& out) {
size_t outLength = ((inLength + 2) / 3) * 4;
size_t j = out.size();
out.resize(j + outLength);
for (size_t i = 0; i < inLength; i += 3) {
uint8_t b = (in[i] & 0xFC) >> 2;
out[j++] = EncodeCharBase64(b);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2(%rsi), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
andq $-0x2, %rdx
movq 0x8(%rbx), %r12
leaq (%r12,%rdx,2), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a5be0
testq %r14, %r... | /hbina[P]fatuous/thirdparty/assimp/code/glTF/glTFCommon.cpp |
p2t::Triangle::PointCW(p2t::Point const&) | Point* Triangle::PointCW(const Point& point)
{
if (&point == points_[0]) {
return points_[2];
} else if (&point == points_[1]) {
return points_[0];
} else if (&point == points_[2]) {
return points_[1];
}
assert(0);
return NULL;
} | movq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x542e6a
movq 0x10(%rdi), %rcx
cmpq %rsi, %rcx
je 0x542e69
movq %rcx, %rax
cmpq %rsi, 0x18(%rdi)
jne 0x542e6f
retq
movq 0x18(%rdi), %rax
retq
pushq %rax
leaq 0x931d8(%rip), %rdi # 0x5d604f
leaq 0x9af02(%rip), %rsi # 0x5ddd80
leaq 0x9b017(%rip), %rcx # 0x5dde9c
movl $0... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/common/shapes.cc |
p2t::Triangle::EdgeIndex(p2t::Point const*, p2t::Point const*) | int Triangle::EdgeIndex(const Point* p1, const Point* p2)
{
if (points_[0] == p1) {
if (points_[1] == p2) {
return 2;
} else if (points_[2] == p2) {
return 1;
}
} else if (points_[1] == p1) {
if (points_[2] == p2) {
return 0;
} else if (points_[0] == p2) {
return 2;
}... | movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rsi, %rax
je 0x542f7b
movq 0x18(%rdi), %rdi
cmpq %rsi, %rcx
je 0x542f8c
cmpq %rsi, %rdi
jne 0x542f96
cmpq %rdx, %rax
je 0x542f86
cmpq %rdx, %rcx
jne 0x542f96
jmp 0x542fa2
cmpq %rdx, %rcx
je 0x542f9c
cmpq %rdx, 0x18(%rdi)
jne 0x542f96
movl $0x1, %eax
retq
cmpq %rdx, %rdi
... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/common/shapes.cc |
p2t::Triangle::SetConstrainedEdgeCCW(p2t::Point const&, bool) | void Triangle::SetConstrainedEdgeCCW(const Point& p, bool ce)
{
if (&p == points_[0]) {
constrained_edge[2] = ce;
} else if (&p == points_[1]) {
constrained_edge[0] = ce;
} else {
constrained_edge[1] = ce;
}
} | cmpq %rsi, 0x8(%rdi)
je 0x5430ea
cmpq %rsi, 0x10(%rdi)
je 0x5430ee
movb %dl, 0x1(%rdi)
retq
movb %dl, 0x2(%rdi)
retq
movb %dl, (%rdi)
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/common/shapes.cc |
p2t::Triangle::SetConstrainedEdgeCW(p2t::Point const&, bool) | void Triangle::SetConstrainedEdgeCW(const Point& p, bool ce)
{
if (&p == points_[0]) {
constrained_edge[1] = ce;
} else if (&p == points_[1]) {
constrained_edge[2] = ce;
} else {
constrained_edge[0] = ce;
}
} | cmpq %rsi, 0x8(%rdi)
je 0x543101
cmpq %rsi, 0x10(%rdi)
je 0x543105
movb %dl, (%rdi)
retq
movb %dl, 0x1(%rdi)
retq
movb %dl, 0x2(%rdi)
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/common/shapes.cc |
p2t::Triangle::SetDelunayEdgeCCW(p2t::Point const&, bool) | void Triangle::SetDelunayEdgeCCW(const Point& p, bool e)
{
if (&p == points_[0]) {
delaunay_edge[2] = e;
} else if (&p == points_[1]) {
delaunay_edge[0] = e;
} else {
delaunay_edge[1] = e;
}
} | xorl %eax, %eax
cmpq %rsi, 0x10(%rdi)
setne %al
addq $0x3, %rax
cmpq %rsi, 0x8(%rdi)
movl $0x5, %ecx
cmovneq %rax, %rcx
movb %dl, (%rdi,%rcx)
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/common/shapes.cc |
p2t::Triangle::DebugPrint() | void Triangle::DebugPrint()
{
using namespace std;
cout << points_[0]->x << "," << points_[0]->y << " ";
cout << points_[1]->x << "," << points_[1]->y << " ";
cout << points_[2]->x << "," << points_[2]->y << endl;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movsd (%rax), %xmm0
movq 0x268da3(%rip), %r15 # 0x7abf68
movq %r15, %rdi
callq 0x1a5df0
movq %rax, %r12
leaq 0x91140(%rip), %r14 # 0x5d4317
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a61e0
movq 0x8(%rbx), %r... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/common/shapes.cc |
irr::io::CXMLReaderImpl<char, irr::io::IXMLBase>::CXMLReaderImpl(irr::io::IFileReadCallBack*, bool) | CXMLReaderImpl(IFileReadCallBack* callback, bool deleteCallBack = true)
: TextData(0), P(0), TextBegin(0), TextSize(0), CurrentNodeType(EXN_NONE),
SourceFormat(ETF_ASCII), TargetFormat(ETF_ASCII)
{
if (!callback)
return;
storeTargetFormat();
// read whole xml file
readFile(callback);
// clean up... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x26827d(%rip), %rax # 0x7aba48
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movabsq $0x100000001, %r15 # imm = 0x100000001
movq %r15, 0x3... | /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<char, irr::io::IXMLBase>::getAttributeValueAsFloat(char const*) const | float getAttributeValueAsFloat(const char_type* name) const
{
const SAttribute* attr = getAttributeByName(name);
if (!attr)
return 0;
core::stringc c = attr->Value.c_str();
return static_cast<float>(atof(c.c_str()));
//return fast_atof(c.c_str());
} | pushq %rbx
subq $0x20, %rsp
callq 0x5453a4
testq %rax, %rax
je 0x543ff2
movq 0x10(%rax), %rsi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
callq 0x544446
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x1a5f00
testq %rbx, %rbx
je 0x543fec
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1a5610
m... | /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<char, irr::io::IXMLBase>::getAttributeValueAsFloat(int) const | float getAttributeValueAsFloat(int idx) const
{
const char_type* attrvalue = getAttributeValue(idx);
if (!attrvalue)
return 0;
core::stringc c = attrvalue;
return static_cast<float>(atof(c.c_str()));
//return fast_atof(c.c_str());
} | pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
je 0x54404c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x544446
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x1a5f00
testq %rbx, %rbx
je 0x544046
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
c... | /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::core::array<irr::core::string<char>>::reallocate(unsigned int) | void reallocate(u32 new_size)
{
T* old_data = data;
data = new T[new_size];
allocated = new_size;
s32 end = used < new_size ? used : new_size;
for (s32 i=0; i<end; ++i)
data[i] = old_data[i];
if (allocated < used)
used = allocated;
delete [] old_data;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r12
movl %esi, %r13d
movq %r13, %r14
shlq $0x4, %r14
leaq 0x8(%r14), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1a57a0
movq %rax, %r15
movq %r13, (%rax)
movl %ebp, 0xc(%rsp)
testl %ebp, %ebp
je 0x544... | /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/irrArray.h |
irr::io::CXMLReaderImpl<char, irr::io::IXMLBase>::equalsn(char const*, char const*, int) | bool equalsn(const char_type* str1, const char_type* str2, int len)
{
int i;
for(i=0; str1[i] && str2[i] && i < len; ++i)
if (str1[i] != str2[i])
return false;
// if one (or both) of the strings was smaller then they
// are only equal if they have the same lenght
return (i == len) || (str1[i] == 0 &&... | movb (%rsi), %al
testb %al, %al
je 0x544e65
movslq %ecx, %r8
xorl %edi, %edi
cmpq %r8, %rdi
jge 0x544e75
movb (%rdx,%rdi), %r9b
testb %r9b, %r9b
je 0x544e75
cmpb %r9b, %al
jne 0x544e7b
movb 0x1(%rsi,%rdi), %al
incq %rdi
testb %al, %al
jne 0x544e43
movl %edi, %esi
jmp 0x544e69
xorl %esi, %esi
xorl %edi, %edi
movb $0x1, ... | /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned short, irr::io::IXMLBase>::createSpecialCharacterList() | void createSpecialCharacterList()
{
// list of strings containing special symbols,
// the first character is the special character,
// the following is the symbol string without trailing &.
SpecialCharacters.push_back("&");
SpecialCharacters.push_back("<lt;");
SpecialCharacters.push_back(">gt;");
S... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x58, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x98aeb(%rip), %rsi # 0x5de044
movq %r14, %rdi
callq 0x545d60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x545ae4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x54557a
callq 0x1a5610
xorps %xmm0,... | /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
irr::io::CXMLReaderImpl<unsigned short, irr::io::IXMLBase>::read() | virtual bool read()
{
// if not end reached, parse the node
if (P && (unsigned int)(P - TextBegin) < TextSize - 1 && *P != 0)
{
parseCurrentNode();
return true;
}
_IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
return false;
} | movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x5457e3
movq %rax, %rcx
subq 0x18(%rdi), %rcx
shrq %rcx
movl 0x20(%rdi), %edx
decl %edx
cmpl %ecx, %edx
jbe 0x5457e3
cmpw $0x0, (%rax)
je 0x5457e3
pushq %rax
callq 0x545e36
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
void irr::io::CXMLReaderImpl<unsigned short, irr::io::IXMLBase>::convertTextData<unsigned long>(unsigned long*, char*, int) | void convertTextData(src_char_type* source, char* pointerToStore, int sizeWithoutHeader)
{
// convert little to big endian if necessary
if (sizeof(src_char_type) > 1 &&
isLittleEndian(TargetFormat) != isLittleEndian(SourceFormat))
convertToLittleEndian(source);
// check if conversion is necessary:
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
movl 0x2c(%rdi), %ecx
cmpl $0x6, %ecx
setb %dl
movb $0x2b, %al
shrb %cl, %al
movq %rsi, %r15
movl 0x28(%rdi), %ecx
andb %dl, %al
cmpl $0x5, %ecx
ja 0x5459a4
movl $0x2b, %edx
btl %ecx, %edx
jae 0x5459a4
testb %al, %al
... | /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.