name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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 - ay*bx
*/
const double ax = node.next->point->x - node.point->x;
const double ay = node.next->point->y - node.point->y;
const double bx = node.prev->point->x - node.point->x;
const double by = node.prev->point->y - node.point->y;
return atan2(ax * by - ay * bx, ax * bx + ay * 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, %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm0, %xmm1
mulsd %xmm5, %xmm0
subsd %xmm3, %xmm0
mulsd %xmm2, %xmm5
addsd %xmm5, %xmm1
jmp 0x1a5490
nop
| /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->prev->point) == CW) {
// Next is concave
FillLeftConcaveEdgeEvent(tcx, edge, node);
} else{
// Next is convex
}
}
}
} | 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
movupd (%rcx), %xmm2
movupd (%rsi), %xmm3
subpd %xmm2, %xmm3
movapd %xmm0, %xmm1
subpd %xmm2, %xmm1
shufpd $0x1, %xmm1, %xmm1 # xmm1 = xmm1[1,0]
mulpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
subsd %xmm2, %xmm1
movapd %xmm1, %xmm2
andpd 0x5dc6d(%rip), %xmm2 # 0x5605e0
movsd 0xc39d5(%rip), %xmm3 # 0x5c6350
ucomisd %xmm2, %xmm3
ja 0x5029e2
ucomisd 0x89bff(%rip), %xmm1 # 0x58c588
ja 0x5029e2
movq (%rbx), %rax
movq 0x18(%rdx), %rcx
movq (%rcx), %rcx
movupd (%rcx), %xmm1
movupd (%rax), %xmm2
subpd %xmm1, %xmm2
subpd %xmm1, %xmm0
shufpd $0x1, %xmm0, %xmm0 # xmm0 = xmm0[1,0]
mulpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
subsd %xmm1, %xmm0
movapd %xmm0, %xmm1
andpd 0x5dc1a(%rip), %xmm1 # 0x5605e0
movsd 0xc3982(%rip), %xmm2 # 0x5c6350
ucomisd %xmm1, %xmm2
ja 0x5029e2
ucomisd 0x89bac(%rip), %xmm0 # 0x58c588
jbe 0x502918
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 || op->pt.X < opBottom->pt.X)
opBottom = op;
}
op = op->next;
}
outRec->bottomPt = opBottom;
opBottom->idx = outRec->idx;
op = opBottom;
//find vertices either side of bottomPt (skipping duplicate points) ....
OutPt *opPrev = op->prev;
OutPt *opNext = op->next;
while (op != opPrev && PointsEqual(op->pt, opPrev->pt))
opPrev = opPrev->prev;
while (op != opNext && PointsEqual(op->pt, opNext->pt))
opNext = opNext->next;
IntPoint ip1, ip2;
ip1.X = op->pt.X - opPrev->pt.X;
ip1.Y = op->pt.Y - opPrev->pt.Y;
ip2.X = opNext->pt.X - op->pt.X;
ip2.Y = opNext->pt.Y - op->pt.Y;
if (UseFullInt64Range)
return Int128(ip1.X) * Int128(ip2.Y) - Int128(ip2.X) * Int128(ip1.Y) >= 0;
else
return (ip1.X * ip2.Y - ip2.X * ip1.Y) >= 0;
} | 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), %rdx
cmpq %rcx, %rdx
jne 0x5045f0
jmp 0x50461a
xorl %eax, %eax
retq
movq %rcx, %rax
movq %rax, 0x20(%rdi)
movl (%rdi), %ecx
movl %ecx, (%rax)
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
movq %rax, %r8
movq 0x20(%r8), %r8
cmpq %r8, %rax
je 0x504658
cmpq 0x8(%r8), %rdx
jne 0x504658
cmpq 0x10(%r8), %rcx
je 0x504631
jmp 0x504658
cmpq 0x8(%rdi), %rdx
jne 0x50465d
cmpq 0x10(%rdi), %rcx
jne 0x50465d
movq 0x18(%rdi), %rdi
cmpq %rdi, %rax
jne 0x504648
movq %rdx, %r9
subq 0x8(%r8), %r9
movq %rcx, %r14
subq 0x10(%r8), %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
subq %rdx, %r15
subq %rcx, %rax
testb %sil, %sil
je 0x504710
leaq 0x40(%rsp), %rsi
movq %r9, 0x8(%rsi)
sarq $0x3f, %r9
movq %r9, (%rsi)
leaq 0x30(%rsp), %rdx
movq %rax, 0x8(%rdx)
sarq $0x3f, %rax
movq %rax, (%rdx)
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x50a8e2
leaq 0x10(%rsp), %rsi
movq %r15, 0x8(%rsi)
sarq $0x3f, %r15
movq %r15, (%rsi)
movq %rsp, %rdx
movq %r14, 0x8(%rdx)
sarq $0x3f, %r14
movq %r14, (%rdx)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x50a8e2
movq 0x8(%rbx), %rax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq %rdx, %rsi
negq %rsi
movq %rcx, %rdi
negq %rdi
testq %rdx, %rdx
notq %rcx
cmoveq %rdi, %rcx
subq %rdx, %rax
cmpq %rsi, %rax
adcq (%rbx), %rcx
cmoveq %rax, %rcx
testq %rcx, %rcx
setns %al
jmp 0x50471e
imulq %r9, %rax
imulq %r14, %r15
cmpq %r15, %rax
setge %al
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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->xcurr;
e->ytop = e->next->ycurr;
e->windDelta = 1;
} else
{
e->xtop = e->xcurr;
e->ytop = e->ycurr;
e->xbot = e->next->xcurr;
e->ybot = e->next->ycurr;
e->windDelta = -1;
}
SetDx(*e);
e->polyType = polyType;
e->outIdx = -1;
} | 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(%r15), %rcx
jge 0x5052ab
movq %rax, 0x20(%r14)
movq %rcx, 0x28(%r14)
movq 0x10(%r15), %rdx
movq %rdx, (%r14)
movq 0x18(%r15), %rsi
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl $0x8, %r9d
movq %rcx, %r8
movq %rsi, %rcx
jmp 0x5052cf
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
movq %rax, %rdx
movq 0x10(%r15), %rax
movq %rax, 0x20(%r14)
movq 0x18(%r15), %rsi
movl $0x1, %edi
movl $0x28, %r9d
movq %rsi, %r8
movq %rsi, (%r14,%r9)
movl %edi, 0x48(%r14)
subq %rcx, %r8
jne 0x5052e6
movsd 0xd4ea4(%rip), %xmm0 # 0x5da188
jmp 0x5052f7
subq %rdx, %rax
cvtsi2sd %rax, %xmm0
cvtsi2sd %r8, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%r14)
movl %ebx, 0x40(%r14)
movl $0xffffffff, 0x54(%r14) # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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->next->Y ) )
tmpLm = tmpLm->next;
newLm->next = tmpLm->next;
tmpLm->next = newLm;
}
} | 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 %r14, %rdi
testq %r14, %r14
jne 0x506288
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5062b7
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5062cc
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x5062e8
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a5190
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x1d8731
| /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 (%r14), %rsi
movq %rbx, %rdi
callq 0x5064a4
movq 0x8(%r14), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x5064a4
movq 0x18(%r14), %r14
jmp 0x506475
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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 = ExecuteInternal(true);
if (succeeded) BuildResultEx(solution);
m_ExecuteLocked = false;
return succeeded;
} | 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 %r15d, 0x50(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x20(%rax)
movl %eax, %ebp
testb %al, %al
je 0x5066fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50670c
movb $0x0, 0x78(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x50ad18
nop
| /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 %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x50ace6
nop
| /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 = e2OutIdx; else
jr->poly2Idx = e2->outIdx;
jr->pt2a = IntPoint(e2->xcurr, e2->ycurr);
jr->pt2b = IntPoint(e2->xtop, e2->ytop);
m_Joins.push_back(jr);
} | 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 %xmm0, (%rax)
movups 0x20(%r15), %xmm0
movups %xmm0, 0x10(%rax)
testl %ebp, %ebp
jns 0x5087ae
movl 0x54(%r14), %ebp
movl %ebp, 0x48(%rax)
movups 0x10(%r14), %xmm0
movups %xmm0, 0x28(%rax)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x38(%rax)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x5087d7
movq %rax, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0x5087e8
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x50ceb0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 (outPt1->pt.X < outPt2->pt.X) return outRec1;
else if (outPt1->pt.X > outPt2->pt.X) return outRec2;
else if (outPt1->next == outPt1) return outRec2;
else if (outPt2->next == outPt2) return outRec1;
else if (FirstIsBottomPt(outPt1, outPt2)) return outRec1;
else return outRec2;
} | 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
jg 0x509141
cmpq %rdi, 0x18(%rdi)
je 0x509141
cmpq %rsi, 0x18(%rsi)
je 0x509150
callq 0x505442
testb %al, %al
cmoveq %r14, %rbx
jmp 0x509150
| /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 0x5096c3
retq
movb $0x1, %al
retq
| /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 );
}
delete m_IntersectNodes;
m_IntersectNodes = iNode;
}
} | 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
movq 0x70(%rbx), %rdi
movl $0x28, %esi
callq 0x1a5190
movq %r14, 0x70(%rbx)
movq %r14, %rcx
testq %r14, %r14
jne 0x509e24
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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.edge1 == node2.edge2 || node1.edge2 == node2.edge2)
{
result = node2.pt.X > node1.pt.X;
return node2.edge2->dx > 0 ? !result : result;
}
else return node2.pt.X > node1.pt.X;
}
else return node1.pt.Y > node2.pt.Y;
} | 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 %r9b, %sil
jne 0x509f88
movsd 0x30(%r8), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x509f88
cmpq %rdx, %rcx
jmp 0x509fa9
setg %al
retq
movq 0x10(%rsi), %rdx
movq 0x10(%rdi), %rsi
cmpq %rsi, %rdx
setg %al
movsd 0x30(%rcx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x509f88
cmpq %rsi, %rdx
setle %al
retq
nop
| /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
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
sqrtsd %xmm3, %xmm3
movsd 0x5631e(%rip), %xmm1 # 0x560848
divsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
xorpd 0x56096(%rip), %xmm1 # 0x5605d0
mulsd %xmm2, %xmm1
retq
| /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 0x1a61e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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;
ulong64 int1Lo = ulong64(tmp.lo & 0xFFFFFFFF);
tmp = rhs;
if (tmp.hi < 0) Negate(tmp);
ulong64 int2Hi = ulong64(tmp.lo) >> 32;
ulong64 int2Lo = ulong64(tmp.lo & 0xFFFFFFFF);
//nb: see comments in clipper.pas
ulong64 a = int1Hi * int2Hi;
ulong64 b = int1Lo * int2Lo;
ulong64 c = int1Hi * int2Lo + int1Lo * int2Hi;
tmp.hi = long64(a + (c >> 32));
tmp.lo = long64(c << 32);
tmp.lo += long64(b);
if (ulong64(tmp.lo) < b) tmp.hi++;
if (negate) Negate(tmp);
return tmp;
} | 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), %rcx
movq %rcx, %rdx
negq %rdx
cmpq $0x0, (%rdi)
movl %r8d, %r8d
cmovnsq %rcx, %rdx
movl %edx, %r9d
movq %rdx, %rcx
shrq $0x20, %rcx
movq %rcx, %r10
imulq %rsi, %r10
imulq %r9, %rsi
imulq %r8, %r9
imulq %r8, %rcx
addq %rsi, %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
addq %r10, %rdx
movq %rdx, (%rdi)
shlq $0x20, %rcx
addq %r9, %rcx
movq %rcx, 0x8(%rdi)
jae 0x50a97a
incq %rdx
movq %rdx, (%rdi)
testq %rax, %rax
jns 0x50a99b
testq %rcx, %rcx
je 0x50a990
negq %rcx
movq %rcx, 0x8(%rdi)
notq %rdx
jmp 0x50a998
testq %rdx, %rdx
je 0x50a99b
negq %rdx
movq %rdx, (%rdi)
movq %rdi, %rax
retq
pushq %rax
movl $0x8, %edi
callq 0x1a5680
leaq 0xcfa38(%rip), %rcx # 0x5da3e9
movq %rcx, (%rax)
movq 0x2a160d(%rip), %rsi # 0x7abfc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x1a5b00
nop
| /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 + normals[m_j].Y * m_delta));
if ((normals[m_k].X * normals[m_j].Y - normals[m_j].X * normals[m_k].Y) * m_delta >= 0)
{
double a1 = std::atan2(normals[m_k].Y, normals[m_k].X);
double a2 = std::atan2(-normals[m_j].Y, -normals[m_j].X);
a1 = std::fabs(a2 - a1);
if (a1 > pi) a1 = pi * 2 - a1;
double dx = std::tan((pi - a1)/4) * std::fabs(m_delta * mul);
pt1 = IntPoint((long64)(pt1.X -normals[m_k].Y * dx),
(long64)(pt1.Y + normals[m_k].X * dx));
AddPoint(pt1);
pt2 = IntPoint((long64)(pt2.X + normals[m_j].Y * dx),
(long64)(pt2.Y -normals[m_j].X * dx));
AddPoint(pt2);
}
else
{
AddPoint(pt1);
AddPoint(m_p[m_i][m_j]);
AddPoint(pt2);
}
} | 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(%rcx,%rsi), %xmm2
movsd 0x38(%rdi), %xmm3
movapd %xmm1, %xmm8
mulsd %xmm3, %xmm8
addsd %xmm7, %xmm8
xorpd %xmm4, %xmm4
movapd %xmm8, %xmm9
cmpltsd %xmm4, %xmm9
movsd 0xce69f(%rip), %xmm5 # 0x5da198
movapd %xmm9, %xmm10
andpd %xmm5, %xmm10
movsd 0x54d5d(%rip), %xmm6 # 0x560868
andnpd %xmm6, %xmm9
orpd %xmm10, %xmm9
addsd %xmm8, %xmm9
cvttsd2si %xmm9, %r14
xorps %xmm8, %xmm8
cvtsi2sdq 0x8(%rdx,%rax), %xmm8
movapd %xmm2, %xmm9
mulsd %xmm3, %xmm9
addsd %xmm8, %xmm9
movapd %xmm9, %xmm10
cmpltsd %xmm4, %xmm10
movapd %xmm10, %xmm11
andpd %xmm5, %xmm11
andnpd %xmm6, %xmm10
orpd %xmm11, %xmm10
addsd %xmm9, %xmm10
cvttsd2si %xmm10, %r15
movq %r14, 0x30(%rsp)
movq %r15, 0x38(%rsp)
movsd (%rcx,%rax), %xmm9
movsd 0x8(%rcx,%rax), %xmm10
movapd %xmm9, %xmm11
mulsd %xmm3, %xmm11
addsd %xmm7, %xmm11
movapd %xmm11, %xmm7
cmpltsd %xmm4, %xmm7
movapd %xmm7, %xmm12
andpd %xmm5, %xmm12
andnpd %xmm6, %xmm7
orpd %xmm12, %xmm7
addsd %xmm11, %xmm7
cvttsd2si %xmm7, %rax
movapd %xmm1, %xmm7
mulsd %xmm10, %xmm7
mulsd %xmm3, %xmm10
addsd %xmm8, %xmm10
movapd %xmm10, %xmm8
cmpltsd %xmm4, %xmm8
andpd %xmm8, %xmm5
andnpd %xmm6, %xmm8
orpd %xmm5, %xmm8
addsd %xmm10, %xmm8
cvttsd2si %xmm8, %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
mulsd %xmm2, %xmm9
subsd %xmm9, %xmm7
mulsd %xmm3, %xmm7
ucomisd %xmm4, %xmm7
jae 0x50bc34
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x50c43e
movq (%rbx), %rax
movq 0x50(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x58(%rbx), %rsi
shlq $0x4, %rsi
addq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x50c43e
jmp 0x50bd85
movaps %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm0
callq 0x1a5490
movsd %xmm0, 0x28(%rsp)
movq 0x20(%rbx), %rax
movq 0x58(%rbx), %rcx
shlq $0x4, %rcx
movsd (%rax,%rcx), %xmm1
movsd 0x8(%rax,%rcx), %xmm0
movapd 0x54969(%rip), %xmm2 # 0x5605d0
xorpd %xmm2, %xmm0
xorpd %xmm2, %xmm1
callq 0x1a5490
subsd 0x28(%rsp), %xmm0
andpd 0x5495e(%rip), %xmm0 # 0x5605e0
movsd 0xb93ae(%rip), %xmm2 # 0x5c5038
subsd %xmm0, %xmm2
movsd 0xb9c1a(%rip), %xmm1 # 0x5c58b0
movapd %xmm1, %xmm3
cmpltsd %xmm0, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm3
orpd %xmm2, %xmm3
subsd %xmm3, %xmm1
mulsd 0xce501(%rip), %xmm1 # 0x5da1b8
movapd %xmm1, %xmm0
callq 0x1a5930
movapd 0x10(%rsp), %xmm1
mulsd 0x38(%rbx), %xmm1
andpd 0x5490d(%rip), %xmm1 # 0x5605e0
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm2
movapd %xmm1, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movq 0x20(%rbx), %rax
movq 0x60(%rbx), %rcx
shlq $0x4, %rcx
movsd 0x8(%rax,%rcx), %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movsd (%rax,%rcx), %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
leaq 0x30(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x50c43e
xorps %xmm0, %xmm0
cvtsi2sdq (%rsp), %xmm0
movq 0x20(%rbx), %rax
movq 0x58(%rbx), %rcx
shlq $0x4, %rcx
movsd 0x8(%rax,%rcx), %xmm1
movapd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%rsp), %xmm0
mulsd (%rax,%rcx), %xmm2
subsd %xmm2, %xmm0
cvttsd2si %xmm0, %rax
movq %rdx, (%rsp)
movq %rax, 0x8(%rsp)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x50c43e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /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 );
if( ddl_nullptr != id ) {
// store the node
DDLNode *node( createDDLNode( id, this ) );
if( ddl_nullptr != node ) {
pushNode( node );
} else {
std::cerr << "nullptr returned by creating DDLNode." << std::endl;
}
delete id;
Name *name_(ddl_nullptr);
in = OpenDDLParser::parseName(in, end, &name_);
std::unique_ptr<Name> name(name_);
if( ddl_nullptr != name && ddl_nullptr != node ) {
const std::string nodeName( name->m_id->m_buffer );
node->setName( nodeName );
}
std::unique_ptr<Property> first;
in = lookForNextToken(in, end);
if (*in == Grammar::OpenPropertyToken[0]) {
in++;
std::unique_ptr<Property> prop, prev;
while (*in != Grammar::ClosePropertyToken[0] && in != end) {
Property *prop_(ddl_nullptr);
in = OpenDDLParser::parseProperty(in, end, &prop_);
prop.reset(prop_);
in = lookForNextToken(in, end);
if (*in != Grammar::CommaSeparator[0] && *in != Grammar::ClosePropertyToken[0]) {
logInvalidTokenError(in, Grammar::ClosePropertyToken, m_logCallback);
return ddl_nullptr;
}
if (ddl_nullptr != prop && *in != Grammar::CommaSeparator[0]) {
if (ddl_nullptr == first) {
first = std::move(prop);
}
if (ddl_nullptr != prev) {
prev->m_next = prop.release();
}
prev = std::move(prop);
}
}
++in;
}
// set the properties
if (first && ddl_nullptr != node) {
node->setProperties(first.release());
}
}
return in;
} | 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 $0x100100002600, %r14 # imm = 0x100100002600
cmpq %r15, %rax
je 0x50deb3
movzbl (%rbx), %eax
cmpq $0x2c, %rax
ja 0x50deb3
btq %rax, %r14
jae 0x50deb3
incq %rbx
cmpq %r15, %rbx
jne 0x50de99
movq %r15, %rbx
movq 0x60(%rsp), %r13
testq %r13, %r13
je 0x50e1fc
movq %r12, 0x48(%rsp)
movq 0x10(%r13), %r12
testq %r12, %r12
je 0x50df7f
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %r12, %rdi
callq 0x1a56a0
leaq (%rax,%r12), %rdx
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x209290
movq 0x48(%rsp), %rcx
movq 0x28(%rcx), %rax
cmpq %rax, 0x20(%rcx)
je 0x50df0a
movq -0x8(%rax), %rdx
jmp 0x50df0c
xorl %edx, %edx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x51041c
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x50df4f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x50df66
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x20(%rsp), %rsi
testq %rsi, %rsi
je 0x50df7f
movq 0x48(%rsp), %rdi
callq 0x50dd8c
movb $0x1, %r12b
jmp 0x50dfce
movq 0x29e052(%rip), %r12 # 0x7abfd8
leaq 0xcc53f(%rip), %rsi # 0x5da4cc
movl $0x25, %edx
movq %r12, %rdi
callq 0x1a61e0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x1a6320
movsbl %al, %esi
movq %r12, %rdi
callq 0x1a5970
movq %rax, %rdi
callq 0x1a5800
xorl %r12d, %r12d
movq $0x0, 0x20(%rsp)
movq %r13, %rdi
callq 0x51077e
movl $0x18, %esi
movq %r13, %rdi
callq 0x1a5190
leaq 0x68(%rsp), %rbp
movq $0x0, (%rbp)
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x50e556
movq %rax, %r13
movq (%rbp), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
sete %cl
xorb $0x1, %r12b
orb %r12b, %cl
jne 0x50e05a
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x23ca1c
leaq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x51034a
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50e05a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq $0x0, 0x10(%rsp)
cmpq %r15, %r13
je 0x50e084
movzbl (%r13), %eax
cmpq $0x2c, %rax
ja 0x50e088
btq %rax, %r14
jae 0x50e088
incq %r13
cmpq %r15, %r13
jne 0x50e068
movq %r15, %r13
movb (%r13), %al
cmpb $0x28, %al
jne 0x50e1e1
leaq 0x1(%r13), %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x18(%rsp)
cmpq %r15, %rbx
je 0x50e19d
cmpb $0x29, 0x1(%r13)
je 0x50e19d
leaq 0x50(%rsp), %r13
movq $0x0, 0x50(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x50e628
movq %rax, %rbx
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rbp
movq %rax, 0x8(%rsp)
testq %rbp, %rbp
je 0x50e0fc
movq %rbp, %rdi
callq 0x510a54
movl $0x20, %esi
movq %rbp, %rdi
callq 0x1a5190
cmpq %r15, %rbx
je 0x50e11b
movzbl (%rbx), %eax
cmpq $0x2c, %rax
ja 0x50e11d
btq %rax, %r14
jae 0x50e11d
incq %rbx
cmpq %r15, %rbx
jne 0x50e101
movq %r15, %rbx
movb (%rbx), %al
cmpb $0x29, %al
je 0x50e12d
movzbl %al, %ecx
cmpl $0x2c, %ecx
jne 0x50e211
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
sete %dl
cmpb $0x2c, %al
sete %al
orb %dl, %al
jne 0x50e18f
cmpq $0x0, 0x10(%rsp)
jne 0x50e150
movq %rcx, 0x10(%rsp)
xorl %ecx, %ecx
movq 0x18(%rsp), %rbp
testq %rbp, %rbp
je 0x50e181
movq %rcx, 0x18(%rbp)
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
callq 0x510a54
movl $0x20, %esi
movq %rbp, %rdi
callq 0x1a5190
jmp 0x50e18f
movq $0x0, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
cmpq %r15, %rbx
je 0x50e19d
cmpb $0x29, (%rbx)
jne 0x50e0b9
incq %rbx
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0x50fcca
leaq 0x8(%rsp), %rdi
callq 0x50fcca
testb %bpl, %bpl
je 0x50e1e6
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
sete %al
orb %al, %r12b
jne 0x50e1e8
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x51035a
jmp 0x50e1e8
movq %r13, %rbx
jmp 0x50e1e8
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x50fcca
leaq 0x58(%rsp), %rdi
callq 0x50fcfe
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x52865(%rip), %rsi # 0x560a86
leaq 0x5285f(%rip), %rdx # 0x560a87
leaq 0x28(%rsp), %rdi
callq 0x209290
movq 0x48(%rsp), %rax
movq (%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x50e946
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x50e25e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
xorl %ebp, %ebp
jmp 0x50e1a3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x50e2e3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x50e2e3
jmp 0x50e2e0
movq %rax, %rbx
jmp 0x50e2f7
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50e301
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x50e301
movq %rax, %rbx
jmp 0x50e301
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x50e2c7
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x50e30b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x50e30b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x50fcca
leaq 0x8(%rsp), %rdi
callq 0x50fcca
leaq 0x10(%rsp), %rdi
callq 0x50fcca
leaq 0x58(%rsp), %rdi
callq 0x50fcfe
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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 = parseStructureBody( in, end, error );
if(in == ddl_nullptr){
return ddl_nullptr;
}
} while ( *in != *Grammar::CloseBracketToken);
++in;
} else {
++in;
logInvalidTokenError( in, std::string( Grammar::OpenBracketToken ), m_logCallback );
return ddl_nullptr;
}
in = lookForNextToken( in, end );
// pop node from stack after successful parsing
if( !error ) {
popNode();
}
return 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, %r12
jae 0x50e368
incq %rax
cmpq %r14, %rax
jne 0x50e34b
movb (%r14), %cl
movq %r14, %rax
cmpb $0x7b, %cl
jne 0x50e3ce
leaq 0x7(%rsp), %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x50eb82
testq %rax, %rax
je 0x50e40f
cmpb $0x7d, (%rax)
jne 0x50e372
incq %rax
cmpq %r14, %rax
je 0x50e3b3
movzbl (%rax), %ecx
cmpq $0x2c, %rcx
ja 0x50e3b3
btq %rcx, %r12
jae 0x50e3b3
incq %rax
cmpq %r14, %rax
jne 0x50e399
movq %r14, %rax
cmpb $0x0, 0x7(%rsp)
jne 0x50e411
movq 0x28(%rbx), %rcx
cmpq %rcx, 0x20(%rbx)
je 0x50e411
addq $-0x8, %rcx
movq %rcx, 0x28(%rbx)
jmp 0x50e411
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movw $0x7b, (%r14)
movq $0x1, -0x8(%r14)
incq %rax
movq (%rbx), %rdx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x50e946
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x50e40f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x50e437
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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, type, arrayLen );
if( Value::ddl_none != type ) {
// parse a primitive data type
in = lookForNextToken( in, end );
if( *in == Grammar::OpenBracketToken[ 0 ] ) {
Reference *refs( ddl_nullptr );
DataArrayList *dtArrayList( ddl_nullptr );
Value *values( ddl_nullptr );
if( 1 == arrayLen ) {
size_t numRefs( 0 ), numValues( 0 );
in = parseDataList( in, end, type, &values, numValues, &refs, numRefs );
setNodeValues( top(), values );
setNodeReferences( top(), refs );
} else if( arrayLen > 1 ) {
in = parseDataArrayList( in, end, type, &dtArrayList );
setNodeDataArrayList( top(), dtArrayList );
} else {
std::cerr << "0 for array is invalid." << std::endl;
error = true;
}
}
in = lookForNextToken( in, end );
if( *in != '}' ) {
logInvalidTokenError( in, std::string( Grammar::CloseBracketToken ), m_logCallback );
return ddl_nullptr;
} else {
//in++;
}
} else {
// parse a complex data type
in = parseNextNode( in, end );
}
return in;
} | 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 $0x100100002600, %rbp # imm = 0x100100002600
cmpq %rdx, %rdi
je 0x50ebde
movzbl (%rdi), %eax
cmpq $0x2c, %rax
ja 0x50ebde
btq %rax, %rbp
jae 0x50ebde
incq %rdi
cmpq %r14, %rdi
jne 0x50ebc4
movq %r14, %rdi
leaq 0x44(%rsp), %r13
movl $0xffffffff, (%r13) # imm = 0xFFFFFFFF
leaq 0x38(%rsp), %rcx
movq $0x0, (%rcx)
movq %r14, %rsi
movq %r13, %rdx
callq 0x50ee5e
movq %rax, %r15
movl (%r13), %edx
cmpl $-0x1, %edx
je 0x50ecf9
cmpq %r14, %r15
je 0x50ec32
movzbl (%r15), %eax
cmpq $0x2c, %rax
ja 0x50ec35
btq %rax, %rbp
jae 0x50ec35
incq %r15
cmpq %r14, %r15
jne 0x50ec17
movq %r14, %r15
movb (%r15), %al
cmpb $0x7b, %al
jne 0x50eda8
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x50ed23
cmpq $0x1, %rax
jne 0x50ed6d
xorl %eax, %eax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x48(%rsp), %r8
movq %rax, (%r8)
movq %rcx, (%rsp)
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r9
movq %r15, %rdi
movq %r14, %rsi
callq 0x50ef74
movq %rax, %r15
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rax
cmpq %rax, %rcx
je 0x50ecc9
movq -0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
sete %dl
testq %rdi, %rdi
sete %r8b
orb %dl, %r8b
jne 0x50ecc9
callq 0x5103f6
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rax
cmpq %rax, %rcx
je 0x50eda8
movq -0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x50eda8
callq 0x51040e
jmp 0x50eda8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x50de42
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x50e314
movq 0x29d2ae(%rip), %r13 # 0x7abfd8
leaq 0xcb7c1(%rip), %rsi # 0x5da4f2
movl $0x17, %edx
movq %r13, %rdi
callq 0x1a61e0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x1a6320
movsbl %al, %esi
movq %r13, %rdi
callq 0x1a5970
movq %rax, %rdi
callq 0x1a5800
movb $0x1, (%r12)
jmp 0x50eda8
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x50f3c6
movq %rax, %r15
movq 0x28(%rbx), %rax
cmpq %rax, 0x20(%rbx)
je 0x50eda8
movq -0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x50eda8
callq 0x510402
cmpq %r14, %r15
je 0x50edc8
movzbl (%r15), %eax
cmpq $0x2c, %rax
ja 0x50edcb
btq %rax, %rbp
jae 0x50edcb
incq %r15
cmpq %r14, %r15
jne 0x50edad
movq %r14, %r15
movb (%r15), %al
cmpb $0x7d, %al
je 0x50ee10
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
movw $0x7d, (%r14)
movq $0x1, -0x8(%r14)
movq (%rbx), %rdx
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x50e946
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x50ee0d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
xorl %r15d, %r15d
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x50ee3c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /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 in;
}
in = lookForNextToken( in, end );
if( *in == Grammar::OpenBracketToken[ 0 ] ) {
++in;
Value *currentValue( ddl_nullptr );
Reference *refs( ddl_nullptr );
DataArrayList *prev( ddl_nullptr ), *currentDataList( ddl_nullptr );
do {
size_t numRefs( 0 ), numValues( 0 );
currentValue = ddl_nullptr;
in = parseDataList( in, end, type, ¤tValue, numValues, &refs, numRefs );
if( ddl_nullptr != currentValue || 0 != numRefs ) {
if( ddl_nullptr == prev ) {
*dataArrayList = createDataArrayList( currentValue, numValues, refs, numRefs );
prev = *dataArrayList;
} else {
currentDataList = createDataArrayList( currentValue, numValues, refs, numRefs );
if( ddl_nullptr != prev ) {
prev->m_next = currentDataList;
prev = currentDataList;
}
}
}
} while( Grammar::CommaSeparator[ 0 ] == *in && in != end );
in = lookForNextToken( in, end );
++in;
}
return in;
} | 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 (%rbx), %eax
cmpq $0x2c, %rax
ja 0x50f427
btq %rax, %r13
jae 0x50f427
incq %rbx
cmpq %r14, %rbx
jne 0x50f40a
movb (%r14), %al
movq %r14, %rbx
cmpb $0x7b, %al
jne 0x50f4e0
movq %rcx, 0x30(%rsp)
incq %rbx
leaq 0x20(%rsp), %rax
movq $0x0, (%rax)
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %r12, 0x18(%rsp)
movq %r12, 0x10(%rsp)
movq %r12, 0x28(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
leaq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x20(%rsp), %r9
callq 0x50ef74
movq %rax, %rbx
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq %rdi, %rax
orq %rcx, %rax
je 0x50f4b4
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x50fc64
leaq 0x10(%r15), %rcx
testq %r15, %r15
cmoveq 0x30(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, %r15
cmpq %r14, %rbx
je 0x50f4be
cmpb $0x2c, (%rbx)
je 0x50f449
cmpq %r14, %rbx
je 0x50f4dd
movzbl (%rbx), %eax
cmpq $0x2c, %rax
ja 0x50f4dd
btq %rax, %r13
jae 0x50f4dd
incq %rbx
cmpq %r14, %rbx
jne 0x50f4c3
movq %r14, %rbx
incq %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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::CommaSeparator[ 0 ] == *in ) {
in = getNextSeparator( in, end );
if( Grammar::CommaSeparator[ 0 ] == *in ) {
in = parseName( in, end, &nextName );
if( nextName ) {
names.push_back( nextName );
}
} else {
break;
}
}
return in;
} | 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, %rax
je 0x50f575
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x50f568
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x50f575
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x50ff44
cmpb $0x2c, (%rbx)
jne 0x50f640
movb $0x2c, %al
movd 0xcaec8(%rip), %xmm0 # 0x5da450
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3]
movdqa %xmm0, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movzbl %al, %esi
movd %esi, %xmm0
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
cmpb $0x2c, %sil
sete %dl
cmpb $0x5b, %sil
sete %cl
andb $-0x2, %sil
cmpb $0x28, %sil
sete %sil
punpcklbw %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3]
pcmpeqb 0x10(%rsp), %xmm0
movmskps %xmm0, %edi
testl %edi, %edi
setne %dil
cmpq %r15, %rbx
je 0x50f61f
orb %dl, %sil
orb %sil, %cl
orb %cl, %dil
je 0x50f61f
cmpb $0x2c, %al
jne 0x50f640
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x50e556
movq %rax, %rbx
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x50f635
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x50f62a
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x50f635
movb 0x1(%rbx), %al
incq %rbx
jmp 0x50f59b
movq %r14, %rdi
movq %r12, %rdx
callq 0x50ff44
cmpb $0x2c, (%rbx)
movb $0x2c, %al
je 0x50f59b
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /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)
callq 0x1a57a0
movq %rax, %r12
movq %rax, 0x10(%r15)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a5220
movb $0x0, (%r12,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /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 char*) new Reference(*ref);
}
}
} | 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 %r14, %rsi
callq 0x510924
movq %r15, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc8d46(%rip), %rdi # 0x5dab8d
leaq 0xc8805(%rip), %rsi # 0x5da653
leaq 0xc8d4a(%rip), %rcx # 0x5dab9f
movl $0x115, %edx # imm = 0x115
callq 0x1a5270
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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 );
break;
case Value::ddl_int8:
data->m_size = sizeof( int8 );
break;
case Value::ddl_int16:
data->m_size = sizeof( int16 );
break;
case Value::ddl_int32:
data->m_size = sizeof( int32 );
break;
case Value::ddl_int64:
data->m_size = sizeof( int64 );
break;
case Value::ddl_unsigned_int8:
data->m_size = sizeof( uint8 );
break;
case Value::ddl_unsigned_int16:
data->m_size = sizeof( uint16 );
break;
case Value::ddl_unsigned_int32:
data->m_size = sizeof( uint32 );
break;
case Value::ddl_unsigned_int64:
data->m_size = sizeof( uint64 );
break;
case Value::ddl_half:
data->m_size = sizeof( short );
break;
case Value::ddl_float:
data->m_size = sizeof( float );
break;
case Value::ddl_double:
data->m_size = sizeof( double );
break;
case Value::ddl_string:
data->m_size = sizeof( char )*(len+1);
break;
case Value::ddl_ref:
data->m_size = 0;
break;
case Value::ddl_none:
case Value::ddl_types_max:
default:
break;
}
if( data->m_size ) {
data->m_data = new unsigned char[ data->m_size ];
::memset(data->m_data,0,data->m_size);
}
return data;
} | 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 %ebp, %ecx
leaq 0xc8539(%rip), %rdx # 0x5da60c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, %r14d
jmp 0x5120fa
movl $0x4, %r14d
jmp 0x5120fa
movl $0x8, %r14d
jmp 0x5120fa
movl $0x2, %r14d
movq %r14, (%rax)
movq %r14, %rdi
callq 0x1a57a0
movq %rax, 0x10(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1a54e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
incq %r14
movq %r14, (%rax)
jne 0x5120fd
jmp 0x512116
| /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 -= length * s; // update interval
if (length < AC__MinLength) renorm_dec_interval(); // renormalization
return s;
} | 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, %edx
movl %edx, 0x1c(%rdi)
shll $0x8, %r8d
movl %r8d, 0x20(%rdi)
incq %rcx
cmpl $0x10000, %esi # imm = 0x10000
movl %r8d, %esi
jb 0x512474
retq
| /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
// update interval
if (bit == 0) {
length = x;
++M.bit_0_count;
}
else {
value -= x;
length -= x;
}
if (length < AC__MinLength) renorm_dec_interval(); // renormalization
if (--M.bits_until_update == 0) M.update(); // periodic model update
return bit; // return data bit value
} | 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 $0xffffff, %eax # imm = 0xFFFFFF
ja 0x5126cd
movl 0x1c(%rdi), %ecx
movq 0x10(%rdi), %rdx
incq %rdx
movl %eax, %r8d
shll $0x8, %ecx
movq %rdx, 0x10(%rdi)
movzbl (%rdx), %r9d
orl %r9d, %ecx
movl %ecx, 0x1c(%rdi)
shll $0x8, %r8d
movl %r8d, 0x20(%rdi)
incq %rdx
cmpl $0x10000, %eax # imm = 0x10000
movl %r8d, %eax
jb 0x5126a7
decl 0x4(%rsi)
jne 0x5126da
movq %rsi, %rdi
callq 0x5125fc
xorl %eax, %eax
cmpl %ebp, %ebx
setae %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /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
{
AC_Error("invalid codec buffer size");
}
if (mode != 0) AC_Error("cannot set buffer while encoding or decoding");
if (user_buffer != 0) { // user provides memory buffer
buffer_size = max_code_bytes;
code_buffer = user_buffer; // set buffer for compressed data
delete [] new_buffer; // free anything previously assigned
new_buffer = 0;
return;
}
if (max_code_bytes <= buffer_size) return; // enough available
buffer_size = max_code_bytes; // assign new memory
delete [] new_buffer; // free anything previously assigned
if ((new_buffer = new unsigned char[buffer_size+16]) == 0) // 16 extra bytes
AC_Error("cannot assign memory for compressed data buffer");
code_buffer = new_buffer; // set buffer for compressed data
} | 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 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x512c80
callq 0x1a5610
movl 0x24(%rbx), %esi
addl $0x10, %esi
movq %rsi, %rdi
callq 0x1a57a0
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
popq %rbx
retq
leaq 0xc7fd5(%rip), %rdi # 0x5dac70
callq 0x512cba
leaq 0xc7fe3(%rip), %rdi # 0x5dac8a
callq 0x512cba
| /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 |= 0x80;
if (putc(file_byte, code_file) == EOF)
AC_Error("cannot write compressed data to file");
header_bytes++;
} while (nb);
// write compressed data
if (fwrite(code_buffer, 1, code_bytes, code_file) != code_bytes)
AC_Error("cannot write compressed data to file");
return code_bytes + header_bytes; // bytes used
} | 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 0x1a54f0
cmpl $-0x1, %eax
je 0x512f3b
movl %r13d, %eax
shrl $0x7, %eax
incl %ebp
cmpl $0x7f, %r13d
movl %eax, %r13d
ja 0x512ee0
movq (%r14), %rdi
movl %r15d, %r14d
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a63f0
cmpq %r14, %rax
jne 0x512f3b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc7dfa(%rip), %rdi # 0x5dad3c
callq 0x512cba
nop
| /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) { // assign memory for data model
data_symbols = number_of_symbols;
last_symbol = data_symbols - 1;
delete [] distribution;
// define size of table for fast decoding
if (data_symbols > 16) {
unsigned table_bits = 3;
while (data_symbols > (1U << (table_bits + 2))) ++table_bits;
table_size = 1 << table_bits;
table_shift = DM__LengthShift - table_bits;
distribution = new unsigned[data_symbols+table_size+2];
decoder_table = distribution + data_symbols;
}
else { // small alphabet: no table needed
decoder_table = 0;
table_size = table_shift = 0;
distribution = new unsigned[data_symbols];
}
if (distribution == 0) AC_Error("cannot assign model memory");
}
// compute cumulative distribution, decoder table
unsigned s = 0;
double sum = 0.0, p = 1.0 / double(data_symbols);
for (unsigned k = 0; k < data_symbols; k++) {
if (probability) p = probability[k];
if ((p < 0.0001) || (p > 0.9999)) AC_Error("invalid symbol probability");
distribution[k] = unsigned(sum * (1 << DM__LengthShift));
sum += p;
if (table_size == 0) continue;
unsigned w = distribution[k] >> table_shift;
while (s < w) decoder_table[++s] = k - 1;
}
if (table_size != 0) {
decoder_table[0] = 0;
while (s <= table_size) decoder_table[++s] = data_symbols - 1;
}
if ((sum < 0.9999) || (sum > 1.0001)) AC_Error("invalid probabilities");
} | 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, %rdi
je 0x51302d
callq 0x1a5610
movl 0x10(%rbx), %r15d
cmpl $0x11, %r15d
jb 0x51307b
movl $0xfffffff3, %eax # imm = 0xFFFFFFF3
leal 0x12(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
incl %eax
cmpl %edx, %r15d
ja 0x513038
leal 0xf(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, 0x18(%rbx)
negl %eax
movl %eax, 0x1c(%rbx)
leal (%r15,%rdx), %edi
addl $0x2, %edi
shlq $0x2, %rdi
callq 0x1a57a0
movq %rax, (%rbx)
movl %r15d, %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x8(%rbx)
jmp 0x51309f
xorl %r12d, %r12d
movq %r12, 0x8(%rbx)
movq %r12, 0x18(%rbx)
leal (,%r15,4), %edi
callq 0x1a57a0
movq %rax, (%rbx)
testl %r15d, %r15d
je 0x513193
movl %r15d, %eax
cvtsi2sd %rax, %xmm0
movsd 0x4d799(%rip), %xmm1 # 0x560848
divsd %xmm0, %xmm1
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0xb3a67(%rip), %xmm2 # 0x5c6b28
movsd 0xb3297(%rip), %xmm3 # 0x5c6360
movsd 0xc7b7f(%rip), %xmm4 # 0x5dac50
xorl %r12d, %r12d
testq %r14, %r14
je 0x5130df
movsd (%r14,%rax,8), %xmm1
ucomisd %xmm1, %xmm2
ja 0x513199
ucomisd %xmm3, %xmm1
ja 0x513199
movapd %xmm0, %xmm5
mulsd %xmm4, %xmm5
cvttsd2si %xmm5, %rcx
movq (%rbx), %rdx
movl %ecx, (%rdx,%rax,4)
cmpl $0x0, 0x18(%rbx)
je 0x513138
movq (%rbx), %rcx
movl (%rcx,%rax,4), %edx
movb 0x1c(%rbx), %cl
shrl %cl, %edx
cmpl %edx, %r12d
jae 0x513138
leal -0x1(%rax), %ecx
movl %r12d, %esi
movl %edx, %edi
movq 0x8(%rbx), %r8
movl %ecx, 0x4(%r8,%rsi,4)
incq %rsi
cmpq %rsi, %rdi
jne 0x513124
movl %edx, %r12d
addsd %xmm1, %xmm0
incq %rax
movl 0x10(%rbx), %ecx
cmpq %rcx, %rax
jb 0x5130d4
cmpl $0x0, 0x18(%rbx)
je 0x51316f
movq 0x8(%rbx), %rax
movl $0x0, (%rax)
cmpl 0x18(%rbx), %r12d
ja 0x51316f
movl 0x10(%rbx), %eax
decl %eax
movq 0x8(%rbx), %rcx
incl %r12d
movl %eax, (%rcx,%r12,4)
jmp 0x513157
movsd 0xb31e9(%rip), %xmm1 # 0x5c6360
ucomisd %xmm0, %xmm1
ja 0x5131b1
ucomisd 0xc7ad3(%rip), %xmm0 # 0x5dac58
ja 0x5131b1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorpd %xmm0, %xmm0
jmp 0x513147
leaq 0xc7c10(%rip), %rdi # 0x5dadb0
callq 0x512cba
leaq 0xc7be5(%rip), %rdi # 0x5dad91
callq 0x512cba
leaq 0xc7c13(%rip), %rdi # 0x5dadcb
callq 0x512cba
nop
| /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;
last_symbol = data_symbols - 1;
delete [] distribution;
// define size of table for fast decoding
if (data_symbols > 16) {
unsigned table_bits = 3;
while (data_symbols > (1U << (table_bits + 2))) ++table_bits;
table_size = 1 << table_bits;
table_shift = DM__LengthShift - table_bits;
distribution = new unsigned[2*data_symbols+table_size+2];
decoder_table = distribution + 2 * data_symbols;
}
else { // small alphabet: no table needed
decoder_table = 0;
table_size = table_shift = 0;
distribution = new unsigned[2*data_symbols];
}
symbol_count = distribution + data_symbols;
if (distribution == 0) AC_Error("cannot assign model memory");
}
reset(); // initialize model
} | 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 0x24(%rbx), %r14d
cmpl $0x11, %r14d
jb 0x513274
movl $0xfffffff3, %eax # imm = 0xFFFFFFF3
leal 0x12(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
incl %eax
cmpl %edx, %r14d
ja 0x513230
leal 0xf(%rax), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, 0x2c(%rbx)
negl %eax
movl %eax, 0x30(%rbx)
leal (%r14,%r14), %r15d
leal (%rdx,%r14,2), %edi
addl $0x2, %edi
shlq $0x2, %rdi
callq 0x1a57a0
movq %rax, (%rbx)
leaq (%rax,%r15,4), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x51328e
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, 0x2c(%rbx)
leal (,%r14,8), %edi
callq 0x1a57a0
movq %rax, (%rbx)
movl %r14d, %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5132c0
leaq 0xc7ae4(%rip), %rdi # 0x5dad91
callq 0x512cba
| /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);
symbols_until_update = update_cycle = (data_symbols + 6) >> 1;
} | 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 $0x6, %eax
shrl %eax
movl %eax, 0x1c(%rbx)
movl %eax, 0x20(%rbx)
popq %rbx
retq
nop
| /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(unsigned long i = 0; i < size; ++i)
{
bstream.WriteUIntASCII(data[i]);
}
bstream.WriteUInt32ASCII(start, bstream.GetSize() - start);
return O3DGC_OK;
} | 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, %ebp
leaq 0xf(%rsp), %r12
movq %r14, %r13
movl %r13d, %eax
andb $0x7f, %al
movb %al, 0xf(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5145a8
shrq $0x7, %r13
decq %rbp
jne 0x513356
testq %r14, %r14
je 0x513392
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x514268
incq %r12
cmpq %r12, %r14
jne 0x51337b
movq 0x10(%rbx), %rdx
movq 0x10(%rsp), %rsi
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x5142e2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
unsigned long size = bstream.ReadUInt32Bin(iterator);
if (size == 0)
{
return O3DGC_OK;
}
long minValue = bstream.ReadUInt32Bin(iterator) - O3DGC_MAX_LONG;
unsigned char * buffer = 0;
bstream.GetBuffer(iterator, buffer);
iterator += sizeSize;
data.Allocate(size);
Arithmetic_Codec acd;
acd.set_buffer(sizeSize, buffer);
acd.start_decoder();
Adaptive_Data_Model mModelValues(M+2);
Static_Bit_Model bModel0;
Adaptive_Bit_Model bModel1;
unsigned long value;
#ifdef DEBUG_VERBOSE
printf("-----------\nsize %i\n", size);
fprintf(g_fileDebugTF, "size %i\n", size);
#endif //DEBUG_VERBOSE
for(unsigned long i = 0; i < size; ++i)
{
value = acd.decode(mModelValues);
if ( value == M)
{
value += acd.ExpGolombDecode(0, bModel0, bModel1);
}
data.PushBack(value + minValue);
#ifdef DEBUG_VERBOSE
printf("%i\t%i\n", i, data[i]);
fprintf(g_fileDebugTF, "%i\t%i\n", i, data[i]);
#endif //DEBUG_VERBOSE
}
#ifdef DEBUG_VERBOSE
fflush(g_fileDebugTF);
#endif //DEBUG_VERBOSE
return O3DGC_OK;
} | 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), %rax
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4d5326
movq %r12, %rcx
movq %rax, %r12
movq (%r13), %rax
movq (%rbp), %rbp
addq %rax, %rbp
addq %rcx, %rax
addq $-0xc, %rax
movq %rax, (%r13)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d6f44
leaq 0x18(%rsp), %r13
movq %r13, %rdi
callq 0x512c12
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
callq 0x512c36
leaq 0x18(%rsp), %rdi
callq 0x512d4e
leal 0x2(%rbx), %esi
leaq 0x60(%rsp), %rdi
callq 0x5131ce
leaq 0x4(%rsp), %rdi
callq 0x512f64
leaq 0x4c(%rsp), %rdi
callq 0x512fa2
addq $-0x7fffffff, %r12 # imm = 0x80000001
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r13, %rdi
leaq 0x60(%rsp), %rsi
callq 0x512aea
movl %eax, %eax
cmpq %rbx, %rax
jne 0x513fe3
movq %r13, %rdi
xorl %esi, %esi
leaq 0x4(%rsp), %rdx
leaq 0x4c(%rsp), %rcx
callq 0x4d7c28
movl %eax, %eax
addq %rbx, %rax
addq %r12, %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5144d4
decq %r15
jne 0x513fb6
leaq 0x60(%rsp), %rdi
callq 0x5132b2
leaq 0x18(%rsp), %rdi
callq 0x512cac
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x514030
jmp 0x514030
jmp 0x514029
movq %rax, %rbx
jmp 0x51403d
jmp 0x514030
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x5132b2
leaq 0x18(%rsp), %rdi
callq 0x512cac
movq %rbx, %rdi
callq 0x1a5b90
| /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)
{
#ifdef DEBUG_VERBOSE
g_fileDebugTF = fopen("Load_new.txt", "w");
#endif //DEBUG_VERBOSE
if (streamType == O3DGC_STREAM_TYPE_ASCII)
{
LoadUIntData(m_numTFANs , bstream, iterator);
LoadUIntData(m_degrees , bstream, iterator);
LoadUIntData(m_configs , bstream, iterator);
LoadBinData (m_operations, bstream, iterator);
LoadIntData (m_indices , bstream, iterator);
if (decodeTrianglesOrder)
{
LoadUIntData(m_trianglesOrder , bstream, iterator);
}
}
else
{
LoadIntACEGC(m_numTFANs , 4 , bstream, iterator);
LoadIntACEGC(m_degrees , 16, bstream, iterator);
LoadUIntAC (m_configs , 10, bstream, iterator);
LoadBinAC (m_operations, bstream, iterator);
LoadIntACEGC(m_indices , 8 , bstream, iterator);
if (decodeTrianglesOrder)
{
LoadIntACEGC(m_trianglesOrder , 16, bstream, iterator);
}
}
#ifdef DEBUG_VERBOSE
fclose(g_fileDebugTF);
#endif //DEBUG_VERBOSE
return O3DGC_OK;
} | 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, %rsi
movq %rbx, %rdx
callq 0x513be1
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x513be1
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x513be1
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x513cef
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x513c5d
cmpb $0x0, 0xc(%rsp)
je 0x514257
addq $0x78, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x513be1
jmp 0x514257
movl $0x4, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x513edf
movl $0x10, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x513edf
movl $0xa, %esi
movq %rbp, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x513da5
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x51404f
movl $0x8, %esi
movq 0x10(%rsp), %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x513edf
cmpb $0x0, 0xc(%rsp)
je 0x514257
addq $0x78, %r15
movl $0x10, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x513edf
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_VECTOR_SIZE)
{
m_allocated = O3DGC_DEFAULT_VECTOR_SIZE;
}
T * tmp = new T [m_allocated];
if (m_size > 0)
{
memcpy(tmp, m_buffer, m_size * sizeof(T) );
delete [] m_buffer;
}
m_buffer = tmp;
}
assert(m_size < m_allocated);
m_buffer[m_size++] = value;
} | 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 %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x1a57a0
movq %rax, %r15
testq %r13, %r13
je 0x51455c
movq (%rbx), %r12
leaq (,%r13,8), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a5110
testq %r12, %r12
je 0x51455f
movq %r12, %rdi
callq 0x1a5610
movq 0x8(%rbx), %rbp
movq 0x10(%rbx), %r13
jmp 0x51455f
xorl %r13d, %r13d
movq %r15, (%rbx)
cmpq %rbp, %r13
jae 0x514588
movq (%r14), %rax
movq (%rbx), %rcx
leaq 0x1(%r13), %rdx
movq %rdx, 0x10(%rbx)
movq %rax, (%rcx,%r13,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc31bb(%rip), %rdi # 0x5d774a
leaq 0xc6955(%rip), %rsi # 0x5daeeb
leaq 0xc6b85(%rip), %rcx # 0x5db122
movl $0x58, %edx
callq 0x1a5270
nop
| /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;
case ZLIB_FILEFUNC_SEEK_END:
assimp_origin = aiOrigin_END;
break;
case ZLIB_FILEFUNC_SEEK_SET:
assimp_origin = aiOrigin_SET;
break;
}
return (io_stream->Seek(offset, assimp_origin) == aiReturn_SUCCESS ? 0 : -1);
} | 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) != UNZ_OK)
return nullptr;
ZipFile *zip_file = new ZipFile(m_Size);
if (unzReadCurrentFile(zip_handle, zip_file->m_Buffer.get(), static_cast<unsigned int>(m_Size)) != static_cast<int>(m_Size))
{
// Failed, release the memory
delete zip_file;
zip_file = nullptr;
}
ai_assert(unzCloseCurrentFile(zip_handle) == UNZ_OK);
return zip_file;
} | 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, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x51496e
movq 0x18(%r14), %rsi
movl (%r15), %edx
movq %rbx, %rdi
callq 0x1a5bc0
cmpl (%r15), %eax
je 0x51492f
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1a6460
testl %eax, %eax
je 0x5148ee
leaq 0xc68f7(%rip), %rdi # 0x5db239
leaq 0xc6840(%rip), %rsi # 0x5db189
leaq 0xc6910(%rip), %rcx # 0x5db260
movl $0xef, %edx
callq 0x1a5270
movq %rax, %rbx
movq %r14, %rdi
callq 0x23a164
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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;
const ZipFileInfo &zip_file = (*zip_it).second;
return zip_file.Extract(m_ZipFileHandle);
} | 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 %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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;
if (!iNumVertices) {
for (aiFace* pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace) {
ai_assert( nullptr != pcFace );
ai_assert(3 == pcFace->mNumIndices);
iNumVertices = std::max(iNumVertices,pcFace->mIndices[0]);
iNumVertices = std::max(iNumVertices,pcFace->mIndices[1]);
iNumVertices = std::max(iNumVertices,pcFace->mIndices[2]);
}
}
mNumVertices = iNumVertices;
unsigned int* pi;
// allocate storage
if (bComputeNumTriangles) {
pi = mLiveTriangles = new unsigned int[iNumVertices+1];
::memset(mLiveTriangles,0,sizeof(unsigned int)*(iNumVertices+1));
mOffsetTable = new unsigned int[iNumVertices+2]+1;
} else {
pi = mOffsetTable = new unsigned int[iNumVertices+2]+1;
::memset(mOffsetTable,0,sizeof(unsigned int)*(iNumVertices+1));
mLiveTriangles = NULL; // important, otherwise the d'tor would crash
}
// get a pointer to the end of the buffer
unsigned int* piEnd = pi+iNumVertices;
*piEnd++ = 0u;
// first pass: compute the number of faces referencing each vertex
for (aiFace* pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace)
{
unsigned nind = pcFace->mNumIndices;
unsigned * ind = pcFace->mIndices;
if (nind > 0) pi[ind[0]]++;
if (nind > 1) pi[ind[1]]++;
if (nind > 2) pi[ind[2]]++;
}
// second pass: compute the final offset table
unsigned int iSum = 0;
unsigned int* piCurOut = this->mOffsetTable;
for (unsigned int* piCur = pi; piCur != piEnd;++piCur,++piCurOut) {
unsigned int iLastSum = iSum;
iSum += *piCur;
*piCurOut = iLastSum;
}
pi = this->mOffsetTable;
// third pass: compute the final table
this->mAdjacencyTable = new unsigned int[iSum];
iSum = 0;
for (aiFace* pcFace = pcFaces; pcFace != pcFaceEnd; ++pcFace,++iSum) {
unsigned nind = pcFace->mNumIndices;
unsigned * ind = pcFace->mIndices;
if (nind > 0) mAdjacencyTable[pi[ind[0]]++] = iSum;
if (nind > 1) mAdjacencyTable[pi[ind[1]]++] = iSum;
if (nind > 2) mAdjacencyTable[pi[ind[2]]++] = iSum;
}
// fourth pass: undo the offset computations made during the third pass
// We could do this in a separate buffer, but this would be TIMES slower.
--mOffsetTable;
*mOffsetTable = 0u;
} | 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
cmpl $0x3, (%rax)
jne 0x5164df
movq 0x8(%rax), %rcx
movl (%rcx), %esi
movl 0x4(%rcx), %edx
cmpl %esi, %r12d
cmovbel %esi, %r12d
cmpl %edx, %r12d
ja 0x516324
movl %edx, %r12d
movl 0x8(%rcx), %ecx
cmpl %ecx, %r12d
ja 0x51632f
movl %ecx, %r12d
addq $0x10, %rax
cmpq %rbp, %rax
jne 0x5162fa
jmp 0x51633d
xorl %r12d, %r12d
movl %r12d, 0x18(%rbx)
testb %r8b, %r8b
je 0x516382
leal 0x1(%r12), %r15d
shlq $0x2, %r15
movq %r15, %rdi
callq 0x1a57a0
movq %rax, %r13
movq %rax, 0x10(%rbx)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1a54e0
leal 0x2(%r12), %edi
shlq $0x2, %rdi
callq 0x1a57a0
movq %rax, %r15
addq $0x4, %r15
jmp 0x5163b5
leal 0x2(%r12), %edi
shlq $0x2, %rdi
callq 0x1a57a0
movq %rax, %r15
addq $0x4, %r15
leal 0x1(%r12), %edx
shlq $0x2, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1a54e0
movq $0x0, 0x10(%rbx)
movq %r15, %r13
movq %r15, (%rbx)
movl %r12d, %eax
movl $0x0, (%r13,%rax,4)
movl 0x4(%rsp), %r12d
testl %r12d, %r12d
je 0x516405
movq %r14, %rcx
movl (%rcx), %edx
testl %edx, %edx
je 0x5163fc
movq 0x8(%rcx), %rsi
movl (%rsi), %edi
incl (%r13,%rdi,4)
cmpl $0x1, %edx
je 0x5163fc
movl 0x4(%rsi), %edi
incl (%r13,%rdi,4)
cmpl $0x3, %edx
jb 0x5163fc
movl 0x8(%rsi), %edx
incl (%r13,%rdx,4)
addq $0x10, %rcx
cmpq %rbp, %rcx
jne 0x5163d1
leaq 0x4(,%rax,4), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %esi
movl (%r13,%rcx), %edx
addl %esi, %edx
movl %esi, (%r15,%rcx)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x516411
movl %edx, %edi
shlq $0x2, %rdi
callq 0x1a57a0
movq %rax, 0x8(%rbx)
testl %r12d, %r12d
je 0x5164a2
xorl %eax, %eax
movl (%r14), %ecx
testl %ecx, %ecx
je 0x516494
movq 0x8(%r14), %rdx
movq 0x8(%rbx), %rsi
movl (%rdx), %edi
movl (%r15,%rdi,4), %r8d
leal 0x1(%r8), %r9d
movl %r9d, (%r15,%rdi,4)
movl %eax, (%rsi,%r8,4)
cmpl $0x1, %ecx
je 0x516494
movq 0x8(%rbx), %rsi
movl 0x4(%rdx), %edi
movl (%r15,%rdi,4), %r8d
leal 0x1(%r8), %r9d
movl %r9d, (%r15,%rdi,4)
movl %eax, (%rsi,%r8,4)
cmpl $0x3, %ecx
jb 0x516494
movq 0x8(%rbx), %rcx
movl 0x8(%rdx), %edx
movl (%r15,%rdx,4), %esi
leal 0x1(%rsi), %edi
movl %edi, (%r15,%rdx,4)
movl %eax, (%rcx,%rsi,4)
addq $0x10, %r14
incl %eax
cmpq %rbp, %r14
jne 0x51643d
movq (%rbx), %r15
leaq -0x4(%r15), %rax
movq %rax, (%rbx)
movl $0x0, -0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc4fce(%rip), %rdi # 0x5db495
leaq 0xc4fd9(%rip), %rsi # 0x5db4a7
leaq 0xc5055(%rip), %rcx # 0x5db52a
movl $0x3f, %edx
callq 0x1a5270
leaq 0xc50a9(%rip), %rdi # 0x5db58f
leaq 0xc4fba(%rip), %rsi # 0x5db4a7
leaq 0xc5036(%rip), %rcx # 0x5db52a
movl $0x40, %edx
callq 0x1a5270
| /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();
SceneCombiner::CopySceneFlat(_dest,src[0]);
}
else *_dest = src[0];
return;
}
if (*_dest)(*_dest)->~aiScene();
else *_dest = new aiScene();
// Create a dummy scene to serve as master for the others
aiScene* master = new aiScene();
master->mRootNode = new aiNode();
master->mRootNode->mName.Set("<MergeRoot>");
std::vector<AttachmentInfo> srcList (src.size());
for (unsigned int i = 0; i < srcList.size();++i) {
srcList[i] = AttachmentInfo(src[i],master->mRootNode);
}
// 'master' will be deleted afterwards
MergeScenes (_dest, master, srcList, flags);
} | 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
movq (%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x516c4e
movl $0x80, %edi
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2407d2
movq %r15, (%rbx)
movl $0x80, %edi
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2407d2
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r12
movq %rax, %rdi
callq 0x2402f8
movq %r12, 0x8(%r15)
movl $0xb, (%r12)
movabsq $0x6f52656772654d3c, %rax # imm = 0x6F52656772654D3C
movq %rax, 0x4(%r12)
movl $0x3e746f6f, 0xb(%r12) # imm = 0x3E746F6F
movb $0x0, 0xf(%r12)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x51a8a8
movq 0x8(%rsp), %rax
cmpq %rax, 0x10(%rsp)
je 0x516bcc
movl $0x1, %ecx
xorl %edx, %edx
movq (%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x8(%r15), %rdi
shlq $0x4, %rdx
movq %rsi, (%rax,%rdx)
movq %rdi, 0x8(%rax,%rdx)
movl %ecx, %edx
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rsi
subq %rax, %rsi
sarq $0x4, %rsi
incl %ecx
cmpq %rdx, %rsi
ja 0x516b9a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x516cc8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x516bfd
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
jmp 0x516bfd
movq (%rax), %rax
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x516c35
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x516c45
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
jmp 0x516c40
movq %rax, %rbx
jmp 0x516c45
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %r12, %rdi
jmp 0x516c40
movq %rax, %rbx
movl $0x80, %esi
movq %r15, %rdi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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->mNumProperties = src->mNumProperties;
dest->mProperties = new aiMaterialProperty* [dest->mNumAllocated];
for (unsigned int i = 0; i < dest->mNumProperties;++i)
{
aiMaterialProperty* prop = dest->mProperties[i] = new aiMaterialProperty();
aiMaterialProperty* sprop = src->mProperties[i];
prop->mDataLength = sprop->mDataLength;
prop->mData = new char[prop->mDataLength];
::memcpy(prop->mData,sprop->mData,prop->mDataLength);
prop->mIndex = sprop->mIndex;
prop->mSemantic = sprop->mSemantic;
prop->mKey = sprop->mKey;
prop->mType = sprop->mType;
}
} | 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 (%r14), %rdi
testq %rdi, %rdi
je 0x51850e
callq 0x1a5610
movl 0xc(%rbx), %edi
movl %edi, 0xc(%r14)
movl 0x8(%rbx), %ebp
movl %ebp, 0x8(%r14)
shlq $0x3, %rdi
callq 0x1a57a0
movq %rax, (%r14)
testl %ebp, %ebp
je 0x518610
xorl %r13d, %r13d
movl $0x420, %edi # imm = 0x420
callq 0x1a5230
movq %rax, %r15
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
leaq 0x5(%rax), %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
movaps 0x7980c(%rip), %xmm0 # 0x591d70
movups %xmm0, 0x404(%r15)
movq $0x0, 0x418(%r15)
movq (%r14), %rax
movq %r15, (%rax,%r13,8)
movq (%rbx), %rax
movq (%rax,%r13,8), %rbp
movl 0x40c(%rbp), %r12d
movl %r12d, 0x40c(%r15)
movq %r12, %rdi
callq 0x1a57a0
movq %rax, 0x418(%r15)
movq 0x418(%rbp), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x1a5110
movl 0x408(%rbp), %eax
movl %eax, 0x408(%r15)
movl 0x404(%rbp), %eax
movl %eax, 0x404(%r15)
cmpq %rbp, %r15
je 0x5185f3
movq %r15, %rdi
addq $0x4, %rdi
movl (%rbp), %r12d
movl %r12d, (%r15)
leaq 0x4(%rbp), %rsi
movq %r12, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r15,%r12)
movl 0x410(%rbp), %eax
movl %eax, 0x410(%r15)
incq %r13
movl 0x8(%r14), %eax
cmpq %rax, %r13
jb 0x518533
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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->mMetaData ) {
dest->mMetaData = new aiMetadata( *src->mMetaData );
}
// copy animations
dest->mNumAnimations = src->mNumAnimations;
CopyPtrArray(dest->mAnimations,src->mAnimations,
dest->mNumAnimations);
// copy textures
dest->mNumTextures = src->mNumTextures;
CopyPtrArray(dest->mTextures,src->mTextures,
dest->mNumTextures);
// copy materials
dest->mNumMaterials = src->mNumMaterials;
CopyPtrArray(dest->mMaterials,src->mMaterials,
dest->mNumMaterials);
// copy lights
dest->mNumLights = src->mNumLights;
CopyPtrArray(dest->mLights,src->mLights,
dest->mNumLights);
// copy cameras
dest->mNumCameras = src->mNumCameras;
CopyPtrArray(dest->mCameras,src->mCameras,
dest->mNumCameras);
// copy meshes
dest->mNumMeshes = src->mNumMeshes;
CopyPtrArray(dest->mMeshes,src->mMeshes,
dest->mNumMeshes);
// now - copy the root node of the scene (deep copy, too)
Copy( &dest->mRootNode, src->mRootNode);
// and keep the flags ...
dest->mFlags = src->mFlags;
// source private data might be NULL if the scene is user-allocated (i.e. for use with the export API)
if (dest->mPrivate != NULL) {
ScenePriv(dest)->mPPStepsApplied = ScenePriv(src) ? ScenePriv(src)->mPPStepsApplied : 0;
}
} | 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 0x519da2
movq (%r15), %r14
movq 0x70(%rbx), %r12
testq %r12, %r12
je 0x519dc7
movl $0x18, %edi
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x51aaba
movq %r15, 0x70(%r14)
movl 0x30(%rbx), %r15d
movl %r15d, 0x30(%r14)
testq %r15, %r15
je 0x519e06
movq 0x38(%rbx), %r12
shlq $0x3, %r15
movq %r15, %rdi
callq 0x1a57a0
movq %rax, 0x38(%r14)
xorl %r13d, %r13d
movq 0x38(%r14), %rdi
addq %r13, %rdi
movq (%r12,%r13), %rsi
callq 0x518c04
addq $0x8, %r13
cmpq %r13, %r15
jne 0x519deb
jmp 0x519e0e
movq $0x0, 0x38(%r14)
movl 0x40(%rbx), %r15d
movl %r15d, 0x40(%r14)
testq %r15, %r15
je 0x519e4d
movq 0x48(%rbx), %r12
shlq $0x3, %r15
movq %r15, %rdi
callq 0x1a57a0
movq %rax, 0x48(%r14)
xorl %r13d, %r13d
movq 0x48(%r14), %rdi
addq %r13, %rdi
movq (%r12,%r13), %rsi
callq 0x51842c
addq $0x8, %r13
cmpq %r13, %r15
jne 0x519e32
jmp 0x519e55
movq $0x0, 0x48(%r14)
movl 0x20(%rbx), %r15d
movl %r15d, 0x20(%r14)
testq %r15, %r15
je 0x519e94
movq 0x28(%rbx), %r12
shlq $0x3, %r15
movq %r15, %rdi
callq 0x1a57a0
movq %rax, 0x28(%r14)
xorl %r13d, %r13d
movq 0x28(%r14), %rdi
addq %r13, %rdi
movq (%r12,%r13), %rsi
callq 0x5184bc
addq $0x8, %r13
cmpq %r13, %r15
jne 0x519e79
jmp 0x519e9c
movq $0x0, 0x28(%r14)
movl 0x50(%rbx), %r12d
movl %r12d, 0x50(%r14)
testq %r12, %r12
movq %rbx, (%rsp)
je 0x519eff
movq 0x58(%rbx), %r13
leaq (,%r12,8), %rdi
callq 0x1a57a0
movq %rax, 0x58(%r14)
xorl %ebp, %ebp
movq 0x58(%r14), %rbx
testq %rbx, %rbx
je 0x519ef5
movq (%r13,%rbp,8), %r15
testq %r15, %r15
je 0x519ef5
movl $0x46c, %edi # imm = 0x46C
callq 0x1a5230
movq %rax, (%rbx,%rbp,8)
movl $0x46c, %edx # imm = 0x46C
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a5110
incq %rbp
cmpq %rbp, %r12
jne 0x519ec4
jmp 0x519f07
movq $0x0, 0x58(%r14)
movq (%rsp), %rax
movl 0x60(%rax), %r12d
movl %r12d, 0x60(%r14)
testq %r12, %r12
je 0x519f6a
movq 0x68(%rax), %r13
leaq (,%r12,8), %rdi
callq 0x1a57a0
movq %rax, 0x68(%r14)
xorl %ebp, %ebp
movq 0x68(%r14), %rbx
testq %rbx, %rbx
je 0x519f60
movq (%r13,%rbp,8), %r15
testq %r15, %r15
je 0x519f60
movl $0x438, %edi # imm = 0x438
callq 0x1a5230
movq %rax, (%rbx,%rbp,8)
movl $0x438, %edx # imm = 0x438
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a5110
incq %rbp
cmpq %rbp, %r12
jne 0x519f2f
jmp 0x519f72
movq $0x0, 0x68(%r14)
movq (%rsp), %rbx
movl 0x10(%rbx), %r15d
movl %r15d, 0x10(%r14)
testq %r15, %r15
je 0x519fb5
movq 0x18(%rbx), %r12
shlq $0x3, %r15
movq %r15, %rdi
callq 0x1a57a0
movq %rax, 0x18(%r14)
xorl %r13d, %r13d
movq 0x18(%r14), %rdi
addq %r13, %rdi
movq (%r12,%r13), %rsi
callq 0x518638
addq $0x8, %r13
cmpq %r13, %r15
jne 0x519f9a
jmp 0x519fbd
movq $0x0, 0x18(%r14)
leaq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x518a5e
movl (%rbx), %eax
movl %eax, (%r14)
movq 0x78(%r14), %rax
testq %rax, %rax
je 0x519feb
movq 0x78(%rbx), %rcx
testq %rcx, %rcx
je 0x519fe6
movl 0x8(%rcx), %ecx
jmp 0x519fe8
xorl %ecx, %ecx
movl %ecx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x80, %esi
movq %r14, %rdi
jmp 0x51a012
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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->mNumProperties, dest->mKeys);
dest->mValues = new aiMetadataEntry[src->mNumProperties];
for (unsigned int i = 0; i < src->mNumProperties; ++i) {
aiMetadataEntry& in = src->mValues[i];
aiMetadataEntry& out = dest->mValues[i];
out.mType = in.mType;
switch (dest->mValues[i].mType) {
case AI_BOOL:
out.mData = new bool(*static_cast<bool*>(in.mData));
break;
case AI_INT32:
out.mData = new int32_t(*static_cast<int32_t*>(in.mData));
break;
case AI_UINT64:
out.mData = new uint64_t(*static_cast<uint64_t*>(in.mData));
break;
case AI_FLOAT:
out.mData = new float(*static_cast<float*>(in.mData));
break;
case AI_DOUBLE:
out.mData = new double(*static_cast<double*>(in.mData));
break;
case AI_AISTRING:
out.mData = new aiString(*static_cast<aiString*>(in.mData));
break;
case AI_AIVECTOR3D:
out.mData = new aiVector3D(*static_cast<aiVector3D*>(in.mData));
break;
default:
ai_assert(false);
break;
}
}
} | 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 %r13, %rax
shlq $0xa, %rax
leaq (%rax,%r13,4), %rbp
movq %rbp, %rdi
callq 0x1a57a0
movq %rax, %r15
movq %rax, %r14
addq %rbp, %r14
movq %rax, %rbp
movl $0x0, (%rbp)
movb $0x0, 0x4(%rbp)
leaq 0x5(%rbp), %rdi
movl $0x3ff, %edx # imm = 0x3FF
movl $0x1b, %esi
callq 0x1a54e0
addq $0x404, %rbp # imm = 0x404
cmpq %r14, %rbp
jne 0x51a685
movq 0x8(%rsp), %r14
movq %r15, 0x8(%r14)
shlq $0x4, %r13
movq %r13, %rdi
callq 0x1a57a0
movq %rax, %rbp
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x1a54e0
movq %rbp, 0x10(%r14)
movq %r14, (%r12)
movl (%rbx), %eax
testq %rax, %rax
je 0x51a88d
movq 0x8(%rbx), %r13
movq %rax, 0x10(%rsp)
leaq 0x1(%rax), %rbp
movl $0x404, %r14d # imm = 0x404
cmpq %r15, %r13
je 0x51a71c
movl (%r13), %r12d
movl %r12d, (%r15)
leaq 0x4(%r15), %rdi
leaq 0x4(%r13), %rsi
movq %r12, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r15,%r12)
addq %r14, %r13
addq %r14, %r15
decq %rbp
cmpq $0x1, %rbp
jg 0x51a6fa
movq 0x10(%rsp), %r14
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x1a57a0
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
testq %r14, %r14
je 0x51a898
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%rbx), %r12
movq 0x10(%rcx), %r14
movl (%r12,%r13), %eax
movl %eax, (%r14,%r13)
movq 0x10(%rcx), %rax
movl (%rax,%r13), %eax
cmpq $0x6, %rax
ja 0x51a879
leaq 0xc0e7c(%rip), %rcx # 0x5db5f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %edi
callq 0x1a5230
movq %rax, %r15
movq 0x8(%r12,%r13), %rax
movb (%rax), %al
movb %al, (%r15)
jmp 0x51a86f
movl $0x8, %edi
callq 0x1a5230
movq %rax, %r15
movq 0x8(%r12,%r13), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r15)
jmp 0x51a86f
movl $0x8, %edi
callq 0x1a5230
movq %rax, %r15
movq 0x8(%r12,%r13), %rax
movq (%rax), %rax
movq %rax, (%r15)
jmp 0x51a86f
movl $0x4, %edi
callq 0x1a5230
movq %rax, %r15
movq 0x8(%r12,%r13), %rax
movss (%rax), %xmm0
movss %xmm0, (%r15)
jmp 0x51a86f
movl $0x4, %edi
callq 0x1a5230
movq %rax, %r15
movq 0x8(%r12,%r13), %rax
movl (%rax), %eax
movl %eax, (%r15)
jmp 0x51a86f
movl $0x404, %edi # imm = 0x404
callq 0x1a5230
movq 0x8(%r12,%r13), %rsi
movl (%rsi), %r12d
movl $0x3ff, %ecx # imm = 0x3FF
cmpl %ecx, %r12d
cmovael %ecx, %r12d
movq %rax, %r15
movl %r12d, (%rax)
leaq 0x4(%rax), %rdi
addq $0x4, %rsi
movq %r12, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r15,%r12)
jmp 0x51a86f
movl $0xc, %edi
callq 0x1a5230
movq %rax, %r15
movq 0x8(%r12,%r13), %rax
movq (%rax), %rcx
movq %rcx, (%r15)
movl 0x8(%rax), %eax
movl %eax, 0x8(%r15)
movq %r15, 0x8(%r14,%r13)
movq 0x8(%rsp), %rcx
incq %rbp
movl (%rbx), %eax
addq $0x10, %r13
cmpq %rax, %rbp
jb 0x51a753
jmp 0x51a898
xorl %edi, %edi
callq 0x1a57a0
movq %rax, 0x10(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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,AI_MATKEY_TWOSIDED);
return matHelper;
} | 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 %r15, %rdi
callq 0x209290
movq (%r15), %r14
movq 0x8(%r15), %rax
testl $0xfffffc00, %eax # imm = 0xFFFFFC00
movl $0x3ff, %r15d # imm = 0x3FF
cmovel %eax, %r15d
leaq 0x38(%rsp), %rdi
movl %r15d, -0x4(%rdi)
movq %r14, %rsi
movq %r15, %rdx
callq 0x1a5110
movb $0x0, 0x38(%rsp,%r15)
cmpq %r12, %r14
je 0x51ce43
movq 0x20(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x1a5190
leaq 0x72aef(%rip), %rdx # 0x58f939
leaq 0x34(%rsp), %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x246b54
leaq 0x10(%rsp), %rsi
movl $0x1, (%rsi)
movl $0x4, (%rsp)
leaq 0x7c09d(%rip), %rcx # 0x598f12
movq %rbx, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2468bc
movq %rbx, %rax
addq $0x438, %rsp # imm = 0x438
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1a5190
movq %r14, %rdi
callq 0x1a5b90
| /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 %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x51d75d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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 = aiVector3D(0.0, -1.0, 0.0);
const aiVector3D v4 = aiVector3D(0.0, 0.0, 1.0);
const aiVector3D v5 = aiVector3D(0.0, 0.0, -1.0);
ADD_TRIANGLE(v4,v0,v2);
ADD_TRIANGLE(v4,v2,v1);
ADD_TRIANGLE(v4,v1,v3);
ADD_TRIANGLE(v4,v3,v0);
ADD_TRIANGLE(v5,v2,v0);
ADD_TRIANGLE(v5,v1,v2);
ADD_TRIANGLE(v5,v3,v1);
ADD_TRIANGLE(v5,v0,v3);
return 3;
} | 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 0x3aacf(%rip), %xmm0 # 0x55b5c0
movlps %xmm0, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movsd 0x3aa3e(%rip), %xmm0 # 0x55b540
movsd %xmm0, 0x30(%rsp)
movl %eax, 0x38(%rsp)
movsd 0x3a8bc(%rip), %xmm0 # 0x55b3d0
movsd %xmm0, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movl $0x3f800000, 0x18(%rsp) # imm = 0x3F800000
movq %rax, (%rsp)
movl $0xbf800000, 0x8(%rsp) # imm = 0xBF800000
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520b5e
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520b6f
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520b92
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520ba3
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520bc6
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520bd7
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520bfa
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520c0b
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520c2e
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520c3f
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520c62
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520c73
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520c96
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520ca7
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520cca
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520cdb
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520cfe
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520d0f
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520d32
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520d43
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520d66
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520d77
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520d9a
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520dab
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520dcd
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520ddc
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520dff
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520e10
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520e33
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520e44
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520e66
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520e75
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520e98
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520ea9
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520ecc
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520edd
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520eff
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520f0e
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520f31
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520f42
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520f65
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520f76
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520f98
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520fa7
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520fca
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq 0x8(%rbx), %rsi
addq $0xc, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x520fdb
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x520ff7
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x8(%rbx)
jmp 0x521004
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movl $0x3, %eax
addq $0x60, %rsp
popq %rbx
retq
nop
| /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.0,-1.0,-1.0)*length;
const aiVector3D v2 = aiVector3D(1.0,1.0,-1.0)*length;
const aiVector3D v3 = aiVector3D(-1.0,1.0,-1.0)*length;
const aiVector3D v4 = aiVector3D(-1.0,-1.0,1.0)*length;
const aiVector3D v5 = aiVector3D(1.0,-1.0,1.0)*length;
const aiVector3D v6 = aiVector3D(1.0,1.0,1.0)*length;
const aiVector3D v7 = aiVector3D(-1.0,1.0,1.0)*length;
ADD_QUAD(v0,v3,v2,v1);
ADD_QUAD(v0,v1,v5,v4);
ADD_QUAD(v0,v4,v7,v3);
ADD_QUAD(v6,v5,v1,v2);
ADD_QUAD(v6,v2,v3,v7);
ADD_QUAD(v6,v7,v4,v5);
return (polygons ? 4 : 3);
} | 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 %xmm0, 0x10(%rsp)
movl $0xbf13cd3a, %eax # imm = 0xBF13CD3A
movl %eax, 0x18(%rsp)
movsd 0xba5cb(%rip), %xmm1 # 0x5db910
movsd %xmm1, 0x70(%rsp)
movl %eax, 0x78(%rsp)
movsd 0xba5a9(%rip), %xmm2 # 0x5db900
movsd %xmm2, 0x60(%rsp)
movl %eax, 0x68(%rsp)
movsd 0xba5b7(%rip), %xmm3 # 0x5db920
movsd %xmm3, 0x50(%rsp)
movl %eax, 0x58(%rsp)
movsd %xmm0, 0x40(%rsp)
movl $0x3f13cd3a, %eax # imm = 0x3F13CD3A
movl %eax, 0x48(%rsp)
movsd %xmm1, 0x30(%rsp)
movl %eax, 0x38(%rsp)
movsd %xmm2, (%rsp)
movl %eax, 0x8(%rsp)
movsd %xmm3, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
testl %ebp, %ebp
je 0x5213cb
cmpq %rax, %rsi
je 0x5213eb
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5213fc
cmpq %rax, %rsi
je 0x52141d
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x52142e
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52144f
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521460
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521481
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521492
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5214b3
movl 0x68(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5214c4
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5214e5
movl 0x68(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5214f6
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521517
movl 0x78(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x70(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521528
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521549
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x52155a
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52157b
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x52158c
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5215ad
movl 0x68(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5215be
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5215df
movl 0x78(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x70(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5215f0
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521611
movl 0x78(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x70(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521622
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521643
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521654
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521675
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521686
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5216a7
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5216b8
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5216d9
movl 0x78(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x70(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5216ea
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52170b
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x52171c
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52173d
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x52174e
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52176f
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521780
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5217a1
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5217b2
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5217d3
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5217e4
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521805
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521816
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521837
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521848
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521868
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521879
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52189a
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5218a9
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5218ca
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5218db
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5218fc
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x52190d
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52192e
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x52193f
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521960
movl 0x78(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x70(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521971
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521992
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5219a3
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5219c4
movl 0x68(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x5219d5
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x5219f5
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521a06
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521a27
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521a36
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521a57
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521a68
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521a89
movl 0x68(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521a9a
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521abb
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521acc
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521aec
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521afd
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521b1e
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521b2d
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521b4e
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521b5f
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521b7f
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521b90
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521bb1
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521bc0
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521be1
movl 0x78(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x70(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521bf2
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521c12
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521c23
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521c44
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521c53
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521c74
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521c85
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521ca0
movl 0x78(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x70(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521cb1
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521cd2
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
addq $0xc, (%r14)
jmp 0x521cdf
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521ce9
movl 0x68(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521cfa
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movl $0x4, %eax
jmp 0x521f41
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521d1a
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521d29
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521d4a
movl 0x68(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x60(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521d5b
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521d7c
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521d8d
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521dad
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521dbc
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521ddd
movl 0x58(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x50(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521dee
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521e0f
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521e20
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521e40
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521e4f
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521e70
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521e81
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521ea2
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521eb3
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521ed3
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521ee2
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521f03
movl 0x48(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
movq (%r14), %rsi
addq $0xc, %rsi
movq %rsi, (%r14)
jmp 0x521f14
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x521f2f
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x30(%rsp), %rax
movq %rax, (%rsi)
addq $0xc, (%r14)
jmp 0x521f3c
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x27a4d6
movl $0x3, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /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) {
// No subdivision at all. Need to copy all the meshes .. argh.
if (discard_input) {
for (size_t s = 0; s < nmesh; ++s) {
out[s] = smesh[s];
smesh[s] = NULL;
}
}
else {
for (size_t s = 0; s < nmesh; ++s) {
SceneCombiner::Copy(out+s,smesh[s]);
}
}
return;
}
std::vector<aiMesh*> inmeshes;
std::vector<aiMesh*> outmeshes;
std::vector<unsigned int> maptbl;
inmeshes.reserve(nmesh);
outmeshes.reserve(nmesh);
maptbl.reserve(nmesh);
// Remove pure line and point meshes from the working set to reduce the
// number of edge cases the subdivider is forced to deal with. Line and
// point meshes are simply passed through.
for (size_t s = 0; s < nmesh; ++s) {
aiMesh* i = smesh[s];
// FIX - mPrimitiveTypes might not yet be initialized
if (i->mPrimitiveTypes && (i->mPrimitiveTypes & (aiPrimitiveType_LINE|aiPrimitiveType_POINT))==i->mPrimitiveTypes) {
ASSIMP_LOG_DEBUG("Catmull-Clark Subdivider: Skipping pure line/point mesh");
if (discard_input) {
out[s] = i;
smesh[s] = NULL;
}
else {
SceneCombiner::Copy(out+s,i);
}
continue;
}
outmeshes.push_back(NULL);inmeshes.push_back(i);
maptbl.push_back(static_cast<unsigned int>(s));
}
// Do the actual subdivision on the preallocated storage. InternSubdivide
// *always* assumes that enough storage is available, it does not bother
// checking any ranges.
ai_assert(inmeshes.size()==outmeshes.size()&&inmeshes.size()==maptbl.size());
if (inmeshes.empty()) {
ASSIMP_LOG_WARN("Catmull-Clark Subdivider: Pure point/line scene, I can't do anything");
return;
}
InternSubdivide(&inmeshes.front(),inmeshes.size(),&outmeshes.front(),num);
for (unsigned int i = 0; i < maptbl.size(); ++i) {
ai_assert(nullptr != outmeshes[i]);
out[maptbl[i]] = outmeshes[i];
}
if (discard_input) {
for (size_t s = 0; s < nmesh; ++s) {
delete smesh[s];
}
}
} | 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 %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rsi
callq 0x25bd7e
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x25bd7e
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x2509a4
testq %rbx, %rbx
je 0x522c48
xorl %ebp, %ebp
leaq 0x68(%rsp), %r13
movq %r12, %r15
movq (%r14,%rbp,8), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
decl %eax
cmpl $0x2, %eax
ja 0x522bd7
callq 0x241234
movq %rax, %rdi
leaq 0xb919b(%rip), %rsi # 0x5dbd54
callq 0x241112
cmpb $0x0, 0x4(%rsp)
je 0x522c09
movq 0x8(%rsp), %rax
movq %rax, (%r15)
movq $0x0, (%r14,%rbp,8)
jmp 0x522c38
movq $0x0, 0x68(%rsp)
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x25c222
movq 0x58(%rsp), %rsi
cmpq 0x60(%rsp), %rsi
je 0x522c18
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x58(%rsp)
jmp 0x522c27
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x518638
jmp 0x522c38
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x250da2
movl %ebp, 0x68(%rsp)
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x250c90
incq %rbp
addq $0x8, %r15
cmpq %rbp, %rbx
jne 0x522b98
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
movq %rax, %rdx
subq %rsi, %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rdi
subq %rcx, %rdi
cmpq %rdi, %rdx
jne 0x522df2
sarq $0x3, %rdx
movq 0x18(%rsp), %rdi
subq 0x10(%rsp), %rdi
sarq $0x2, %rdi
cmpq %rdi, %rdx
jne 0x522df2
cmpq %rax, %rsi
je 0x522d49
movq 0x70(%rsp), %rdi
movl 0x2c(%rsp), %r8d
callq 0x522ec4
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
je 0x522cdd
sarq $0x2, %rcx
movl $0x1, %edx
movq 0x30(%rsp), %rsi
xorl %edi, %edi
movq (%rsi,%rdi,8), %r8
testq %r8, %r8
je 0x522dd3
movl (%rax,%rdi,4), %edi
movq %r8, (%r12,%rdi,8)
movl %edx, %edi
incl %edx
cmpq %rdi, %rcx
ja 0x522cc0
testq %rbx, %rbx
sete %al
movl 0x4(%rsp), %ecx
xorb $0x1, %cl
orb %al, %cl
jne 0x522d5d
xorl %r12d, %r12d
movq (%r14,%r12,8), %r15
testq %r15, %r15
je 0x522d02
movq %r15, %rdi
callq 0x240a40
movl $0x520, %esi # imm = 0x520
movq %r15, %rdi
callq 0x1a5190
incq %r12
cmpq %r12, %rbx
jne 0x522cf1
jmp 0x522d5d
cmpb $0x0, 0x4(%rsp)
je 0x522da4
testq %rbx, %rbx
je 0x522dc4
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
movq $0x0, (%r14,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x522d2f
jmp 0x522dc4
callq 0x241234
leaq 0xb9079(%rip), %rsi # 0x5dbdce
movq %rax, %rdi
callq 0x241182
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x522d74
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x522d8b
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x522dc4
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
jmp 0x522dc4
testq %rbx, %rbx
je 0x522dc4
xorl %r15d, %r15d
movq (%r14,%r15,8), %rsi
movq %r12, %rdi
callq 0x518638
incq %r15
addq $0x8, %r12
cmpq %r15, %rbx
jne 0x522dac
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb9039(%rip), %rdi # 0x5dbe13
leaq 0xb8dcb(%rip), %rsi # 0x5dbbac
leaq 0xb8ee8(%rip), %rcx # 0x5dbcd0
movl $0xcf, %edx
callq 0x1a5270
leaq 0xb8f93(%rip), %rdi # 0x5dbd8c
leaq 0xb8dac(%rip), %rsi # 0x5dbbac
leaq 0xb8ec9(%rip), %rcx # 0x5dbcd0
movl $0xc8, %edx
callq 0x1a5270
leaq 0xb8ea8(%rip), %rdi # 0x5dbcc0
leaq 0xb8d8d(%rip), %rsi # 0x5dbbac
leaq 0xb8eaa(%rip), %rcx # 0x5dbcd0
movl $0x91, %edx
callq 0x1a5270
leaq 0xb9007(%rip), %rdi # 0x5dbe3e
leaq 0xb8d6e(%rip), %rsi # 0x5dbbac
leaq 0xb8e8b(%rip), %rcx # 0x5dbcd0
movl $0x92, %edx
callq 0x1a5270
leaq 0xb8edb(%rip), %rdi # 0x5dbd31
leaq 0xb8d4f(%rip), %rsi # 0x5dbbac
leaq 0xb8e6c(%rip), %rcx # 0x5dbcd0
movl $0x95, %edx
callq 0x1a5270
jmp 0x522e74
jmp 0x522e74
jmp 0x522e74
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x522e8e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x522ea5
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x522ebc
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /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 0xa5238(%rip), %rsi # 0x5ca457
leaq 0x8(%rsp), %rdi
movl $0x6, %edx
callq 0x1a61e0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1a5850
leaq 0x6c3ef(%rip), %rsi # 0x591631
leaq 0x8(%rsp), %rdi
movl $0x2, %edx
callq 0x1a61e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1a61e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a5690
movq 0x286d1a(%rip), %rsi # 0x7abf90
leaq 0x8(%rsp), %rdi
callq 0x1a5d00
leaq 0x78(%rsp), %rdi
callq 0x1a5ca0
jmp 0x52529a
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x249fc9
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x286cd8(%rip), %rsi # 0x7abf90
leaq 0x8(%rsp), %rdi
callq 0x1a5d00
leaq 0x78(%rsp), %rdi
callq 0x1a5ca0
movq %rbx, %rdi
callq 0x1a5b90
| /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 0xb6d91(%rip), %rsi # 0x5dc0b0
leaq 0x8(%rsp), %rdi
movl $0x9, %edx
callq 0x1a61e0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1a5850
leaq 0x6c2ef(%rip), %rsi # 0x591631
leaq 0x8(%rsp), %rdi
movl $0x2, %edx
callq 0x1a61e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1a61e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a5690
movq 0x286c1a(%rip), %rsi # 0x7abf90
leaq 0x8(%rsp), %rdi
callq 0x1a5d00
leaq 0x78(%rsp), %rdi
callq 0x1a5ca0
jmp 0x52539a
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x249fc9
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x286bd8(%rip), %rsi # 0x7abf90
leaq 0x8(%rsp), %rdi
callq 0x1a5d00
leaq 0x78(%rsp), %rdi
callq 0x1a5ca0
movq %rbx, %rdi
callq 0x1a5b90
| /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);
const DB::ObjectMap& map = db.GetObjects();
LineSplitter& splitter = db.GetSplitter();
while (splitter) {
bool has_next = false;
std::string s = *splitter;
if (s == "ENDSEC;") {
break;
}
s.erase(std::remove(s.begin(), s.end(), ' '), s.end());
// want one-based line numbers for human readers, so +1
const uint64_t line = splitter.get_index()+1;
// LineSplitter already ignores empty lines
ai_assert(s.length());
if (s[0] != '#') {
ASSIMP_LOG_WARN(AddLineNumber("expected token \'#\'",line));
++splitter;
continue;
}
// ---
// extract id, entity class name and argument string,
// but don't create the actual object yet.
// ---
const std::string::size_type n0 = s.find_first_of('=');
if (n0 == std::string::npos) {
ASSIMP_LOG_WARN(AddLineNumber("expected token \'=\'",line));
++splitter;
continue;
}
const uint64_t id = strtoul10_64(s.substr(1,n0-1).c_str());
if (!id) {
ASSIMP_LOG_WARN(AddLineNumber("expected positive, numeric entity id",line));
++splitter;
continue;
}
std::string::size_type n1 = s.find_first_of('(',n0);
if (n1 == std::string::npos) {
has_next = true;
bool ok = false;
for( ++splitter; splitter; ++splitter) {
const std::string& snext = *splitter;
if (snext.empty()) {
continue;
}
// the next line doesn't start an entity, so maybe it is
// just a continuation for this line, keep going
if (!IsEntityDef(snext)) {
s.append(snext);
n1 = s.find_first_of('(',n0);
ok = (n1 != std::string::npos);
}
else {
break;
}
}
if(!ok) {
ASSIMP_LOG_WARN(AddLineNumber("expected token \'(\'",line));
continue;
}
}
std::string::size_type n2 = s.find_last_of(')');
if (n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';') {
has_next = true;
bool ok = false;
for( ++splitter; splitter; ++splitter) {
const std::string& snext = *splitter;
if (snext.empty()) {
continue;
}
// the next line doesn't start an entity, so maybe it is
// just a continuation for this line, keep going
if (!IsEntityDef(snext)) {
s.append(snext);
n2 = s.find_last_of(')');
ok = !(n2 == std::string::npos || n2 < n1 || n2 == s.length() - 1 || s[n2 + 1] != ';');
} else {
break;
}
}
if(!ok) {
ASSIMP_LOG_WARN(AddLineNumber("expected token \')\'",line));
continue;
}
}
if (map.find(id) != map.end()) {
ASSIMP_LOG_WARN(AddLineNumber((Formatter::format(),"an object with the id #",id," already exists"),line));
}
std::string::size_type ns = n0;
do ++ns; while( IsSpace(s.at(ns)));
std::string::size_type ne = n1;
do --ne; while( IsSpace(s.at(ne)));
std::string type = s.substr(ns,ne-ns+1);
std::transform( type.begin(), type.end(), type.begin(), &Assimp::ToLower<char> );
const char* sz = scheme.GetStaticStringForToken(type);
if(sz) {
const std::string::size_type szLen = n2-n1+1;
char* const copysz = new char[szLen+1];
std::copy(s.c_str()+n1,s.c_str()+n2+1,copysz);
copysz[szLen] = '\0';
db.InternInsert(new LazyObject(db,id,line,sz,copysz));
}
if(!has_next) {
++splitter;
}
}
if (!splitter) {
ASSIMP_LOG_WARN("STEP: ignoring unexpected EOF");
}
if ( !DefaultLogger::isNullLogger()){
ASSIMP_LOG_DEBUG((Formatter::format(),"STEP: got ",map.size()," object records with ",
db.GetRefs().size()," inverse index entries"));
}
} | 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), %rax
movq %rax, 0x70(%rsp)
leaq 0x60(%rsp), %r15
leaq 0x68(%rbx), %rax
movq %rax, 0x98(%rsp)
movq %r12, 0x240(%rsp)
leaq 0x8(%r12), %rax
movq %rax, 0x238(%rsp)
movq 0x158(%rbx), %rcx
movq 0x20(%rcx), %rax
subq 0x18(%rcx), %rax
testl %eax, %eax
je 0x5271a4
movq %r15, 0x50(%rsp)
movq 0x138(%rbx), %rsi
movq 0x140(%rbx), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x20ac60
movq %r14, %rdi
leaq 0xb5af5(%rip), %rsi # 0x5dc15a
callq 0x1a60c0
movl %eax, 0x94(%rsp)
testl %eax, %eax
je 0x527170
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq %rdi, %rsi
movb $0x20, 0xc0(%rsp)
leaq 0xc0(%rsp), %rdx
callq 0x528ba9
movq %rax, %rcx
subq 0x50(%rsp), %rcx
movq %rcx, 0x58(%rsp)
movb $0x0, (%rax)
cmpq $0x0, 0x58(%rsp)
je 0x5272df
movq 0x50(%rsp), %rax
movq 0x70(%rsp), %rcx
movq (%rcx), %rcx
incq %rcx
movq %rcx, 0x78(%rsp)
cmpb $0x23, (%rax)
jne 0x5268ad
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x1a63d0
cmpq $-0x1, %rax
je 0x52698e
movq %rax, %rbp
leaq -0x1(%rax), %rcx
movl $0x1, %edx
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x1a6240
movq 0xc0(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x247403
movq %rax, %r14
movq %r15, %r13
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x52674b
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testq %r14, %r14
je 0x526a6f
leaq 0x50(%rsp), %rdi
movl $0x28, %esi
movq %rbp, %rdx
callq 0x1a63d0
movq %rax, %r15
cmpq $-0x1, %rax
sete 0xf(%rsp)
movq %r14, 0x88(%rsp)
jne 0x526b65
movq 0x70(%rsp), %rdi
callq 0x2cb430
movq $-0x1, %r14
xorl %r15d, %r15d
movq 0x158(%rbx), %rax
movl 0x20(%rax), %ecx
cmpl 0x18(%rax), %ecx
je 0x526b53
leaq 0xd0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x138(%rbx), %rsi
movq 0x140(%rbx), %rdx
addq %rsi, %rdx
leaq 0xc0(%rsp), %rdi
callq 0x20ac60
movq 0xc0(%rsp), %rax
movq 0xc8(%rsp), %rdx
testq %rdx, %rdx
je 0x52682d
cmpb $0x23, (%rax)
jne 0x5267f5
cmpq $0x1, %rdx
jne 0x526868
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1a5d30
movq %r14, %rdi
movl $0x28, %esi
movq %rbp, %rdx
callq 0x1a63d0
movq %rax, %r14
cmpq $-0x1, %rax
setne %r15b
xorl %r12d, %r12d
movq 0xc0(%rsp), %rax
jmp 0x526830
xorl %r12d, %r12d
leaq 0xd0(%rsp), %rcx
cmpq %rcx, %rax
je 0x526850
movq 0xd0(%rsp), %rsi
incq %rsi
movq %rax, %rdi
callq 0x1a5190
testb %r12b, %r12b
jne 0x526b53
movq 0x70(%rsp), %rdi
callq 0x2cb430
jmp 0x526794
movb 0x1(%rax), %sil
movb $0x1, %r12b
cmpb $0x3d, %sil
je 0x526830
movl $0x2, %ecx
cmpb $0x30, %sil
jge 0x52688b
cmpb $0x20, %sil
je 0x526895
jmp 0x5267f5
cmpb $0x39, %sil
ja 0x5267f5
cmpq %rcx, %rdx
je 0x5267f5
movb (%rax,%rcx), %sil
incq %rcx
cmpb $0x3d, %sil
jne 0x52687a
jmp 0x526830
callq 0x241234
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xb59a8(%rip), %rsi # 0x5dc273
leaq 0xb59b3(%rip), %rdx # 0x5dc285
callq 0x209290
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0x82251(%rip), %rdx # 0x5a8b41
movq %rdx, %rsi
callq 0x209290
leaq 0xc0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rcx
callq 0x5251d4
movq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x241182
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x526947
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x526963
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x52697f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x70(%rsp), %rdi
callq 0x2cb430
jmp 0x527170
callq 0x241234
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xb58da(%rip), %rsi # 0x5dc286
leaq 0xb58e5(%rip), %rdx # 0x5dc298
callq 0x209290
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0x82170(%rip), %rdx # 0x5a8b41
movq %rdx, %rsi
callq 0x209290
leaq 0xc0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rcx
callq 0x5251d4
movq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x241182
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x526a28
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x526a44
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x526a60
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x70(%rsp), %rdi
callq 0x2cb430
jmp 0x527170
movq %r13, %r15
callq 0x241234
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xb5809(%rip), %rsi # 0x5dc299
leaq 0xb5826(%rip), %rdx # 0x5dc2bd
callq 0x209290
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0x8208c(%rip), %rdx # 0x5a8b41
movq %rdx, %rsi
callq 0x209290
leaq 0xc0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rcx
callq 0x5251d4
movq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x241182
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x526b0c
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x526b28
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x526b44
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x70(%rsp), %rdi
callq 0x2cb430
jmp 0x527170
testb $0x1, %r15b
leaq 0x60(%rsp), %r13
movq %r14, %r15
je 0x52709b
leaq 0x50(%rsp), %rdi
movl $0x29, %esi
movq $-0x1, %rdx
callq 0x1a5730
movq %rax, %r12
cmpq $-0x1, %rax
sete %al
movq %r15, 0x80(%rsp)
cmpq %r15, %r12
setb %cl
orb %al, %cl
jne 0x526bb9
movq 0x58(%rsp), %rax
decq %rax
cmpq %rax, %r12
je 0x526bb9
movq 0x50(%rsp), %rax
cmpb $0x3b, 0x1(%rax,%r12)
jne 0x526bb9
movq %r13, %r15
jmp 0x526d0c
movq 0x70(%rsp), %rdi
movq %r13, %r15
callq 0x2cb430
xorl %r15d, %r15d
movq 0x158(%rbx), %rax
movl 0x20(%rax), %ecx
cmpl 0x18(%rax), %ecx
je 0x526cf8
leaq 0xd0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x138(%rbx), %rsi
movq 0x140(%rbx), %rdx
addq %rsi, %rdx
leaq 0xc0(%rsp), %rdi
callq 0x20ac60
movq 0xc8(%rsp), %rdx
testq %rdx, %rdx
je 0x526cbc
movq 0xc0(%rsp), %rsi
cmpb $0x23, (%rsi)
jne 0x526c2e
cmpq $0x1, %rdx
jne 0x526c7a
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x1a5d30
movq %r14, %rdi
movl $0x29, %esi
movq $-0x1, %rdx
callq 0x1a5730
movq %rax, %r12
cmpq $-0x1, %rax
sete %al
cmpq 0x80(%rsp), %r12
setb %cl
orb %al, %cl
jne 0x526c75
movq 0x58(%rsp), %rax
decq %rax
cmpq %rax, %r12
jne 0x526cad
xorl %r15d, %r15d
jmp 0x526cbc
movb 0x1(%rsi), %cl
movb $0x1, %r14b
cmpb $0x3d, %cl
je 0x526cbf
movl $0x2, %eax
cmpb $0x30, %cl
jge 0x526c96
cmpb $0x20, %cl
je 0x526c9b
jmp 0x526c2e
cmpb $0x39, %cl
ja 0x526c2e
cmpq %rax, %rdx
je 0x526c2e
movb (%rsi,%rax), %cl
incq %rax
cmpb $0x3d, %cl
jne 0x526c8a
jmp 0x526cbf
movq 0x50(%rsp), %rax
cmpb $0x3b, 0x1(%rax,%r12)
sete %r15b
xorl %r14d, %r14d
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x526ce4
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %r14b, %r14b
jne 0x526cf8
movq 0x70(%rsp), %rdi
callq 0x2cb430
jmp 0x526bc9
movb $0x1, 0xf(%rsp)
testb $0x1, %r15b
leaq 0x60(%rsp), %r15
je 0x527024
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x526e98
movq 0x98(%rsp), %rcx
movq 0x88(%rsp), %rsi
xorl %edx, %edx
cmpq %rsi, 0x20(%rax)
setb %dl
cmovaeq %rax, %rcx
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x526d29
cmpq 0x98(%rsp), %rcx
je 0x526e98
movq 0x88(%rsp), %rax
cmpq 0x20(%rcx), %rax
jb 0x526e98
callq 0x241234
movq %rax, %r13
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
callq 0x1a6170
movl $0x17, %edx
movq %r14, %rdi
leaq 0xb555d(%rip), %rsi # 0x5dc2e4
callq 0x1a61e0
leaq 0xc0(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x1a5850
movl $0xf, %edx
leaq 0xc0(%rsp), %rdi
leaq 0xb5547(%rip), %rsi # 0x5dc2fc
callq 0x1a61e0
leaq 0x30(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x1a5690
leaq 0xb0(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
leaq 0x81d53(%rip), %rdx # 0x5a8b41
movq %rdx, %rsi
callq 0x209290
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r14, %rcx
callq 0x5251d4
movq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x241182
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x526e36
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x526e5b
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x526e77
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0xc0(%rsp), %rdi
movq 0x28510a(%rip), %rsi # 0x7abf90
callq 0x1a5d00
leaq 0x130(%rsp), %rdi
callq 0x1a5ca0
movq 0x58(%rsp), %rdx
leaq 0x1(%rbp), %rax
cmpq %rax, %rdx
jbe 0x5272ce
movq 0x50(%rsp), %rcx
notq %rbp
addq 0x80(%rsp), %rbp
movzbl (%rcx,%rax), %esi
cmpl $0x20, %esi
je 0x526ec8
cmpl $0x9, %esi
jne 0x526ed8
incq %rax
decq %rbp
cmpq %rdx, %rax
jne 0x526eba
jmp 0x5272cb
movq 0x80(%rsp), %rsi
decq %rsi
cmpq %rsi, %rdx
jbe 0x5272bd
movzbl (%rcx,%rsi), %edi
cmpl $0x20, %edi
je 0x526efa
cmpl $0x9, %edi
jne 0x526f02
decq %rsi
decq %rbp
jmp 0x526ee3
leaq 0xc0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %rax, %rdx
movq %rbp, %rcx
callq 0x1a6240
movq 0xc8(%rsp), %rax
testq %rax, %rax
je 0x526f53
movq 0xc0(%rsp), %rcx
xorl %edx, %edx
movzbl (%rcx,%rdx), %esi
leal -0x41(%rsi), %edi
leal 0x20(%rsi), %r8d
cmpb $0x1a, %dil
movzbl %r8b, %edi
cmovael %esi, %edi
movb %dil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x526f31
movq 0x240(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x5286bc
cmpq 0x238(%rsp), %rax
je 0x526fed
movq 0x20(%rax), %r13
testq %r13, %r13
je 0x526fed
movq %r12, %r14
subq 0x80(%rsp), %r14
leaq 0x2(%r14), %rdi
callq 0x1a57a0
movq %rax, %rbp
movq 0x50(%rsp), %rax
movq 0x80(%rsp), %rsi
addq %rax, %rsi
leaq (%rax,%r12), %rdx
incq %rdx
subq %rsi, %rdx
je 0x526fb6
movq %rbp, %rdi
callq 0x1a5240
movb $0x0, 0x1(%rbp,%r14)
movl $0x28, %edi
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq 0x88(%rsp), %rdx
movq %r13, %r8
movq %rbp, %r9
callq 0x527848
movq %rbx, %rdi
movq %r14, %rsi
callq 0x528060
cmpb $0x0, 0xf(%rsp)
jne 0x526ffe
movq 0x70(%rsp), %rdi
callq 0x2cb430
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x527170
movq 0xd0(%rsp), %rsi
jmp 0x527168
callq 0x241234
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xb528f(%rip), %rsi # 0x5dc2d1
leaq 0xb529a(%rip), %rdx # 0x5dc2e3
callq 0x209290
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0x81ada(%rip), %rdx # 0x5a8b41
movq %rdx, %rsi
callq 0x209290
leaq 0xc0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rcx
callq 0x5251d4
movq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x241182
jmp 0x527113
callq 0x241234
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xb5205(%rip), %rsi # 0x5dc2be
leaq 0xb5210(%rip), %rdx # 0x5dc2d0
callq 0x209290
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0x81a63(%rip), %rdx # 0x5a8b41
movq %rdx, %rsi
callq 0x209290
movq %r13, %r15
leaq 0xc0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %r12, %rcx
callq 0x5251d4
movq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x241182
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x527138
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x527154
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x527170
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x527187
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
cmpl $0x0, 0x94(%rsp)
jne 0x526621
movq 0x158(%rbx), %rcx
movq 0x20(%rcx), %rax
subq 0x18(%rcx), %rax
testl %eax, %eax
jne 0x5271bc
callq 0x241234
leaq 0xb5158(%rip), %rsi # 0x5dc30c
movq %rax, %rdi
callq 0x241182
callq 0x2410fc
testb %al, %al
jne 0x5272ab
callq 0x241234
movq %rax, %r14
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
callq 0x1a6170
leaq 0xb5142(%rip), %rsi # 0x5dc32a
movl $0xa, %edx
movq %r15, %rdi
callq 0x1a61e0
movq 0x88(%rbx), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x1a5850
leaq 0x60(%rsp), %r15
leaq 0xb5120(%rip), %rsi # 0x5dc335
leaq 0xc0(%rsp), %rdi
movl $0x15, %edx
callq 0x1a61e0
movq 0xe8(%rbx), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x1a5850
leaq 0xb5109(%rip), %rsi # 0x5dc34b
leaq 0xc0(%rsp), %rdi
movl $0x16, %edx
callq 0x1a61e0
leaq 0xc8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x1a5690
movq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x241112
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x52728a
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x284cff(%rip), %rsi # 0x7abf90
leaq 0xc0(%rsp), %rdi
callq 0x1a5d00
leaq 0x130(%rsp), %rdi
callq 0x1a5ca0
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb5297(%rip), %rdi # 0x5dc55b
xorl %eax, %eax
callq 0x1a5090
movq %rdx, %rax
leaq 0xb5286(%rip), %rdi # 0x5dc55b
movq %rax, %rsi
xorl %eax, %eax
callq 0x1a5090
leaq 0xb4e7c(%rip), %rdi # 0x5dc162
leaq 0xb4e80(%rip), %rsi # 0x5dc16d
leaq 0xb4f00(%rip), %rcx # 0x5dc1f4
movl $0xc0, %edx
callq 0x1a5270
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x527322
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x527322
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x52734c
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x52734c
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x5273d2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x5273d2
jmp 0x5274cd
jmp 0x5274cd
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x1a5190
jmp 0x5274d5
jmp 0x527463
jmp 0x52748d
jmp 0x5274ae
jmp 0x527506
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x527425
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x527425
jmp 0x527422
jmp 0x527463
jmp 0x52748d
jmp 0x5274ae
jmp 0x527506
movq %rax, %rbx
movq 0x284bb7(%rip), %rsi # 0x7abf90
leaq 0xc0(%rsp), %rdi
callq 0x1a5d00
leaq 0x130(%rsp), %rdi
callq 0x1a5ca0
jmp 0x527509
jmp 0x527506
jmp 0x527422
jmp 0x5274d2
movq %rax, %rbx
movq %r13, %r15
jmp 0x52750e
jmp 0x527463
jmp 0x52748d
jmp 0x5274ae
jmp 0x527506
jmp 0x5274d2
movq %rax, %rbx
movq 0x284b64(%rip), %rsi # 0x7abf90
leaq 0xc0(%rsp), %rdi
callq 0x1a5d00
leaq 0x130(%rsp), %rdi
callq 0x1a5ca0
jmp 0x527525
jmp 0x527463
jmp 0x52748d
jmp 0x5274ae
jmp 0x527506
jmp 0x5274cd
jmp 0x5274cd
jmp 0x5274d2
jmp 0x527506
jmp 0x5274cd
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x527490
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x527490
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x5274b1
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x5274b1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x527509
movq 0x20(%rsp), %rsi
jmp 0x5274f2
jmp 0x527506
jmp 0x5274d2
jmp 0x5274cd
movq %rax, %rbx
jmp 0x52750e
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x527509
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x527509
jmp 0x527506
jmp 0x527506
jmp 0x527506
jmp 0x527506
jmp 0x527506
movq %rax, %rbx
leaq 0x60(%rsp), %r15
movq 0x50(%rsp), %rdi
cmpq %r15, %rdi
je 0x527525
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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(type)) {
return;
}
// do a quick scan through the argument tuple and watch out for entity references
const char *a( args );
int64_t skip_depth( 0 );
while ( *a ) {
handleSkippedDepthFromToken(a, skip_depth);
/*if (*a == '(') {
++skip_depth;
} else if (*a == ')') {
--skip_depth;
}*/
if (skip_depth >= 1 && *a=='#') {
if (*(a + 1) != '#') {
/*const char *tmp;
const int64_t num = static_cast<int64_t>(strtoul10_64(a + 1, &tmp));
db.MarkRef(num, id);*/
db.MarkRef(getIdFromToken(a), id);
} else {
++a;
}
}
++a;
}
} | 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 %esi, %esi
cmpq %r8, 0x20(%rax)
setb %sil
cmovaeq %rax, %rcx
movq 0x10(%rax,%rsi,8), %rax
testq %rax, %rax
jne 0x52788b
cmpq %rdx, %rcx
je 0x5278ae
cmpq %r8, 0x20(%rcx)
jbe 0x5278bc
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0xc0, %r15
xorl %r13d, %r13d
movq %rsp, %r12
movzbl (%r14), %eax
cmpl $0x28, %eax
je 0x527903
cmpl $0x29, %eax
je 0x5278fa
testl %eax, %eax
je 0x5278ae
testq %r13, %r13
setle %cl
cmpb $0x23, %al
setne %al
orb %cl, %al
jne 0x52790b
leaq 0x1(%r14), %rdi
cmpb $0x23, 0x1(%r14)
jne 0x527910
movq %rdi, %r14
jmp 0x52790b
movq $-0x1, %rax
jmp 0x527908
movl $0x1, %eax
addq %rax, %r13
incq %r14
jmp 0x5278c9
movq %r12, %rsi
xorl %edx, %edx
callq 0x247403
movq %rax, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x528b18
jmp 0x52790b
| /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)
movb %al, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movl %eax, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movq %rcx, 0x78(%rdi)
movq %rcx, 0x80(%rdi)
movq %rax, 0x88(%rdi)
leaq 0x98(%rdi), %rcx
movl %eax, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movq %rcx, 0xa8(%rdi)
movq %rcx, 0xb0(%rdi)
movq %rax, 0xb8(%rdi)
leaq 0xc8(%rdi), %rcx
movl %eax, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movq %rcx, 0xd8(%rdi)
movq %rcx, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
leaq 0xf8(%rdi), %rcx
movl %eax, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rcx, 0x108(%rdi)
movq %rcx, 0x110(%rdi)
movq %rax, 0x118(%rdi)
movq (%rsi), %rax
movq %rax, 0x120(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x128(%rdi)
testq %rax, %rax
je 0x527d2b
movq 0x28428b(%rip), %rcx # 0x7abfa8
cmpb $0x0, (%rcx)
je 0x527d27
incl 0x8(%rax)
jmp 0x527d2b
lock
incl 0x8(%rax)
movq (%rsi), %rax
xorl %ecx, %ecx
movq %rcx, 0x130(%rbx)
leaq 0x138(%rbx), %r15
leaq 0x148(%rbx), %r12
movq %r12, 0x138(%rbx)
movq %rcx, 0x140(%rbx)
movb $0x0, 0x148(%rbx)
movq %rax, 0x158(%rbx)
movw $0x100, 0x160(%rbx) # imm = 0x100
movb $0x1, 0x162(%rbx)
movl $0x400, %esi # imm = 0x400
movq %r15, %rdi
callq 0x1a5ef0
leaq 0x130(%rbx), %rdi
callq 0x2cb430
movq $0x0, 0x130(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x168(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x527dc0
movq (%r12), %rsi
incq %rsi
callq 0x1a5190
movq 0x128(%rbx), %rdi
testq %rdi, %rdi
je 0x527dd1
callq 0x280464
leaq 0xf0(%rbx), %rdi
leaq 0xc0(%rbx), %r15
leaq 0x90(%rbx), %r12
leaq 0x60(%rbx), %r13
callq 0x3750d0
movq %r15, %rdi
callq 0x34b38e
movq %r12, %rdi
callq 0x375120
movq %r13, %rdi
callq 0x3751f4
movq %rbx, %rdi
callq 0x52814e
movq %r14, %rdi
callq 0x1a5b90
nop
| /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, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
movq %rbp, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0x23ca1c
movq %r15, %rdi
movq %r12, %rsi
callq 0x52819c
movq %rax, %r13
movq %rax, %rdi
callq 0x52857c
cmpq $0x0, 0x20(%rsp)
je 0x527eed
movq %r13, %rax
addq $0x8, %rax
movl 0x18(%rsp), %ecx
movl %ecx, 0x8(%r13)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%r13)
movq 0x28(%rsp), %rdx
movq %rdx, 0x18(%r13)
movq 0x30(%rsp), %rdx
movq %rdx, 0x20(%r13)
movq %rax, 0x8(%rcx)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%r13)
movq %r14, 0x20(%rsp)
movq %rbp, 0x28(%rsp)
movq %rbp, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x527f09
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x10(%rsp), %rdi
callq 0x3751a4
incq %rbx
cmpq %rbx, 0x48(%rsp)
jne 0x527e52
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x527f54
movq %rax, %rbx
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x527f54
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x10(%rsp), %rdi
callq 0x3751a4
movq %rbx, %rdi
callq 0x1a5b90
| /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.mTexCoords.size())
vNew2.resize(sMesh.mFaces.size() * 3);
for (unsigned int i = 0, base = 0; i < sMesh.mFaces.size();++i)
{
D3DS::Face& face = sMesh.mFaces[i];
// Positions
for (unsigned int a = 0; a < 3;++a,++base)
{
vNew[base] = sMesh.mPositions[face.mIndices[a]];
if (sMesh.mTexCoords.size())
vNew2[base] = sMesh.mTexCoords[face.mIndices[a]];
face.mIndices[a] = base;
}
}
sMesh.mPositions = vNew;
sMesh.mTexCoords = vNew2;
} | 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), %rax
je 0x529e4c
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x4, %rax
leaq (%rax,%rax,2), %rsi
movq %rsp, %rdi
callq 0x27a25a
movq 0x18(%rbx), %rdi
cmpq %rdi, 0x20(%rbx)
je 0x529ee8
xorl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %esi
shlq $0x4, %rsi
addq %rdi, %rsi
movl %eax, %eax
xorl %edx, %edx
leaq (%rax,%rdx), %rdi
movl (%rsi,%rdx,4), %r8d
movq (%rbx), %r9
leaq (%r8,%r8,2), %r10
movl %edi, %r8d
movq 0x18(%rsp), %r11
leaq (%r8,%r8,2), %r8
movl 0x8(%r9,%r10,4), %ebp
movl %ebp, 0x8(%r11,%r8,4)
movq (%r9,%r10,4), %r9
movq %r9, (%r11,%r8,4)
movq 0x68(%rbx), %r9
cmpq %r9, 0x70(%rbx)
je 0x529ec0
movl (%rsi,%rdx,4), %r10d
leaq (%r10,%r10,2), %r10
movq (%rsp), %r11
movl 0x8(%r9,%r10,4), %ebp
movl %ebp, 0x8(%r11,%r8,4)
movq (%r9,%r10,4), %r9
movq %r9, (%r11,%r8,4)
movl %edi, (%rsi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x529e6b
incl %ecx
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
sarq $0x4, %rsi
addl %edx, %eax
cmpq %rcx, %rsi
ja 0x529e5e
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x28051a
addq $0x68, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x28051a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x529f1a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x529f31
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x529f53
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x1aaa67
movq %rbx, %rdi
callq 0x1a5b90
| /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 ||
node->aScalingKeys.size() > 1 || node->aCameraRollKeys.size() > 1 ||
node->aTargetPositionKeys.size() > 1)
{
++cnt;
// account for the additional channel for the camera/spotlight target position
if (node->aTargetPositionKeys.size() > 1)++cnt;
}
// Recursively process all children
for (unsigned int i = 0; i < node->mChildren.size();++i)
CountTracks(node->mChildren[i],cnt);
} | 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, %rcx
ja 0x52c1fc
movq 0xa8(%r14), %rcx
subq 0xa0(%r14), %rcx
sarq $0x3, %rcx
imulq %rax, %rcx
cmpq $0x1, %rcx
ja 0x52c1fc
movq 0xd8(%r14), %rcx
subq 0xd0(%r14), %rcx
cmpq $0x10, %rcx
ja 0x52c1fc
movq 0xc0(%r14), %rcx
subq 0xb8(%r14), %rcx
sarq $0x3, %rcx
imulq %rax, %rcx
cmpq $0x2, %rcx
jb 0x52c224
movl (%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
sarq $0x3, %rdx
imulq %rax, %rdx
cmpq $0x2, %rdx
jb 0x52c224
addl $0x2, %ecx
movl %ecx, (%rbx)
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
je 0x52c259
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
movq %rbx, %rsi
callq 0x52c16a
movl %ebp, %ecx
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x52c235
popq %rbx
popq %r14
popq %rbp
retq
| /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.
// generate a flat hiearachy which looks like this:
//
// ROOT_NODE
// |
// ----------------------------------------
// | | | | |
// MESH_0 MESH_1 MESH_2 ... MESH_N CAMERA_0 ....
//
ASSIMP_LOG_WARN("No hierarchy information has been found in the file. ");
pcOut->mRootNode->mNumChildren = pcOut->mNumMeshes +
static_cast<unsigned int>(mScene->mCameras.size() + mScene->mLights.size());
pcOut->mRootNode->mChildren = new aiNode* [ pcOut->mRootNode->mNumChildren ];
pcOut->mRootNode->mName.Set("<3DSDummyRoot>");
// Build dummy nodes for all meshes
unsigned int a = 0;
for (unsigned int i = 0; i < pcOut->mNumMeshes;++i,++a)
{
aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
pcNode->mParent = pcOut->mRootNode;
pcNode->mMeshes = new unsigned int[1];
pcNode->mMeshes[0] = i;
pcNode->mNumMeshes = 1;
// Build a name for the node
pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "3DSMesh_%u",i);
}
// Build dummy nodes for all cameras
for (unsigned int i = 0; i < (unsigned int )mScene->mCameras.size();++i,++a)
{
aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
pcNode->mParent = pcOut->mRootNode;
// Build a name for the node
pcNode->mName = mScene->mCameras[i]->mName;
}
// Build dummy nodes for all lights
for (unsigned int i = 0; i < (unsigned int )mScene->mLights.size();++i,++a)
{
aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
pcNode->mParent = pcOut->mRootNode;
// Build a name for the node
pcNode->mName = mScene->mLights[i]->mName;
}
}
else
{
// First of all: find out how many scaling, rotation and translation
// animation tracks we'll have afterwards
unsigned int numChannel = 0;
CountTracks(mRootNode,numChannel);
if (numChannel)
{
// Allocate a primary animation channel
pcOut->mNumAnimations = 1;
pcOut->mAnimations = new aiAnimation*[1];
aiAnimation* anim = pcOut->mAnimations[0] = new aiAnimation();
anim->mName.Set("3DSMasterAnim");
// Allocate enough storage for all node animation channels,
// but don't set the mNumChannels member - we'll use it to
// index into the array
anim->mChannels = new aiNodeAnim*[numChannel];
}
aiMatrix4x4 m;
AddNodeToGraph(pcOut, pcOut->mRootNode, mRootNode,m);
}
// We used the first and second vertex color set to store some temporary values so we need to cleanup here
for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a)
{
pcOut->mMeshes[a]->mColors[0] = NULL;
pcOut->mMeshes[a]->mColors[1] = NULL;
}
pcOut->mRootNode->mTransformation = aiMatrix4x4(
1.f,0.f,0.f,0.f,
0.f,0.f,1.f,0.f,
0.f,-1.f,0.f,0.f,
0.f,0.f,0.f,1.f) * pcOut->mRootNode->mTransformation;
// If the root node is unnamed name it "<3DSRoot>"
if (::strstr( pcOut->mRootNode->mName.data, "UNNAMED" ) ||
(pcOut->mRootNode->mName.data[0] == '$' && pcOut->mRootNode->mName.data[1] == '$') )
{
pcOut->mRootNode->mName.Set("<3DSRoot>");
}
} | 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, (%rsp)
je 0x52c3a2
leaq 0x14(%rsp), %r15
movl $0x0, (%r15)
movq %r15, %rsi
callq 0x52c16a
movl (%r15), %r15d
testq %r15, %r15
je 0x52c387
movl $0x1, 0x30(%rbx)
movl $0x8, %edi
callq 0x1a57a0
movq %rax, %r13
movq %rax, 0x38(%rbx)
movl $0x448, %edi # imm = 0x448
callq 0x1a5230
movq %rax, %r12
leaq 0x12(%rax), %rdi
movl $0x3f2, %edx # imm = 0x3F2
movl $0x1b, %esi
callq 0x1a54e0
movsd 0x60294(%rip), %xmm0 # 0x58c598
movups %xmm0, 0x408(%r12)
xorl %eax, %eax
movl %eax, 0x418(%r12)
movq %rax, 0x420(%r12)
movl %eax, 0x428(%r12)
movq %rax, 0x430(%r12)
movl %eax, 0x438(%r12)
movq %rax, 0x440(%r12)
movq %r12, (%r13)
movq (%rsp), %r13
movl $0xd, (%r12)
movabsq $0x657473614d534433, %rax # imm = 0x657473614D534433
movq %rax, 0x4(%r12)
movabsq $0x6d696e4172657473, %rax # imm = 0x6D696E4172657473
movq %rax, 0x9(%r12)
movb $0x0, 0x11(%r12)
shlq $0x3, %r15
movq %r15, %rdi
callq 0x1a57a0
movq %rax, 0x420(%r12)
movq 0x8(%rbx), %rdx
movq 0x90(%r13), %rcx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x52adb0
jmp 0x52c61f
callq 0x241234
leaq 0xb0a63(%rip), %rsi # 0x5dce11
movq %rax, %rdi
callq 0x241182
movq 0x98(%r13), %rax
movq 0x38(%rax), %rcx
movq 0x50(%rax), %rdx
subq 0x30(%rax), %rcx
shrq $0x3, %rcx
subq 0x48(%rax), %rdx
shrq $0x3, %rdx
addl %ecx, %edx
addl 0x10(%rbx), %edx
movq 0x8(%rbx), %rax
movl %edx, 0x450(%rax)
movq 0x8(%rbx), %r14
movl 0x450(%r14), %edi
shlq $0x3, %rdi
callq 0x1a57a0
movq %rax, 0x458(%r14)
movq 0x8(%rbx), %rax
movl $0xe, (%rax)
movabsq $0x3e746f6f52796d6d, %rcx # imm = 0x3E746F6F52796D6D
movq %rcx, 0xa(%rax)
movabsq $0x6d6d75445344333c, %rcx # imm = 0x6D6D75445344333C
movq %rcx, 0x4(%rax)
movb $0x0, 0x12(%rax)
cmpl $0x0, 0x10(%rbx)
je 0x52c4b6
leaq 0xb0a1c(%rip), %r13 # 0x5dce56
xorl %r12d, %r12d
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2402f8
movq 0x8(%rbx), %rax
movq 0x458(%rax), %rax
movq %r15, (%rax,%r12,8)
movq 0x8(%rbx), %rax
movq %rax, 0x448(%r15)
movl $0x4, %edi
callq 0x1a57a0
movq %rax, 0x468(%r15)
movl %r12d, (%rax)
movl $0x1, 0x460(%r15)
movq %r15, %rdi
addq $0x4, %rdi
movl $0x400, %esi # imm = 0x400
movq %r13, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1a5890
movl %eax, (%r15)
incq %r12
cmpl %r12d, 0x10(%rbx)
ja 0x52c43d
movq (%rsp), %r13
jmp 0x52c4b9
xorl %r12d, %r12d
movabsq $0x7fffffff8, %rcx # imm = 0x7FFFFFFF8
movq 0x98(%r13), %r14
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
testq %rcx, %rax
je 0x52c57f
movl %r12d, %eax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2402f8
movq 0x8(%rsp), %rax
addq %rbp, %rax
movq 0x8(%rbx), %rcx
movq 0x458(%rcx), %rcx
movl %eax, %eax
movq %r15, (%rcx,%rax,8)
movq 0x8(%rbx), %rax
movq %rax, 0x448(%r15)
movq 0x98(%r13), %r14
movq 0x30(%r14), %rax
movq (%rax,%rbp,8), %rsi
cmpq %rsi, %r15
je 0x52c559
movl (%rsi), %r13d
movl %r13d, (%r15)
movq %r15, %rdi
addq $0x4, %rdi
addq $0x4, %rsi
movq %r13, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r15,%r13)
movq (%rsp), %r13
movq 0x30(%r14), %rax
incq %rbp
movq 0x38(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %eax
cmpq %rax, %rbp
jb 0x52c4e5
addl %ebp, %r12d
movabsq $0x7fffffff8, %rcx # imm = 0x7FFFFFFF8
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
testq %rcx, %rax
je 0x52c61f
movl %r12d, %r14d
xorl %r13d, %r13d
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2402f8
leaq (%r14,%r13), %rax
movq 0x8(%rbx), %rcx
movq 0x458(%rcx), %rcx
movl %eax, %eax
movq %r15, (%rcx,%rax,8)
movq 0x8(%rbx), %rax
movq %rax, 0x448(%r15)
movq (%rsp), %rax
movq 0x98(%rax), %rbp
movq 0x48(%rbp), %rax
movq (%rax,%r13,8), %rsi
cmpq %rsi, %r15
je 0x52c606
movl (%rsi), %r12d
movl %r12d, (%r15)
movq %r15, %rdi
addq $0x4, %rdi
addq $0x4, %rsi
movq %r12, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r15,%r12)
movq 0x48(%rbp), %rax
incq %r13
movq 0x50(%rbp), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl %ecx, %eax
cmpq %rax, %r13
jb 0x52c596
cmpl $0x0, 0x10(%rbx)
je 0x52c64c
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x18(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rax, 0x30(%rdx)
movq 0x18(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rax, 0x38(%rdx)
incq %rcx
movl 0x10(%rbx), %edx
cmpq %rdx, %rcx
jb 0x52c629
movq 0x8(%rbx), %rax
xorps %xmm2, %xmm2
movups 0x404(%rax), %xmm5
movups 0x414(%rax), %xmm6
movups 0x424(%rax), %xmm3
movups 0x434(%rax), %xmm0
movaps %xmm5, %xmm1
mulps %xmm2, %xmm1
movaps %xmm1, %xmm4
subps %xmm6, %xmm1
mulps %xmm2, %xmm6
addps %xmm6, %xmm4
movaps %xmm3, %xmm7
mulps %xmm2, %xmm7
addps %xmm5, %xmm6
addps %xmm7, %xmm6
addps %xmm7, %xmm1
addps %xmm4, %xmm7
addps %xmm0, %xmm7
mulps %xmm2, %xmm0
addps %xmm0, %xmm6
movups %xmm6, 0x404(%rax)
addps %xmm3, %xmm4
addps %xmm0, %xmm4
movups %xmm4, 0x414(%rax)
addps %xmm0, %xmm1
movups %xmm1, 0x424(%rax)
movups %xmm7, 0x434(%rax)
movq 0x8(%rbx), %r14
leaq 0x4(%r14), %rbx
leaq 0x6b4dd(%rip), %rsi # 0x597bad
movq %rbx, %rdi
callq 0x1a57c0
testq %rax, %rax
je 0x52c6fc
movl $0x9, (%r14)
movabsq $0x746f6f525344333c, %rax # imm = 0x746F6F525344333C
movq %rax, (%rbx)
movb $0x3e, 0x8(%rbx)
movb $0x0, 0xd(%r14)
jmp 0x52c708
cmpb $0x24, (%rbx)
jne 0x52c708
cmpb $0x24, 0x5(%r14)
je 0x52c6dd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52c71d
jmp 0x52c71d
jmp 0x52c71d
movq %rax, %rbx
movl $0x478, %esi # imm = 0x478
movq %r15, %rdi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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) translation.y = trans_y->keys[0].value;
if (trans_z) translation.z = trans_z->keys[0].value;
if (rotat_x) angles.x = rotat_x->keys[0].value;
if (rotat_y) angles.y = rotat_y->keys[0].value;
if (rotat_z) angles.z = rotat_z->keys[0].value;
if (scale_x) scaling.x = scale_x->keys[0].value;
if (scale_y) scaling.y = scale_y->keys[0].value;
if (scale_z) scaling.z = scale_z->keys[0].value;
// build the final matrix
aiMatrix4x4 s,rx,ry,rz,t;
aiMatrix4x4::RotationZ(angles.z, rz);
aiMatrix4x4::RotationX(angles.y, rx);
aiMatrix4x4::RotationY(angles.x, ry);
aiMatrix4x4::Translation(translation,t);
aiMatrix4x4::Scaling(scaling,s);
out = t*ry*rx*rz*s;
} | 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), %rax
movss 0x8(%rax), %xmm1
movq 0x20(%rdi), %rax
xorps %xmm2, %xmm2
xorps %xmm5, %xmm5
testq %rax, %rax
je 0x52d2f0
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm5
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x52d302
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm2
movq 0x30(%rdi), %rax
xorps %xmm0, %xmm0
xorps %xmm3, %xmm3
testq %rax, %rax
je 0x52d31a
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm3
movss %xmm2, 0x10(%rsp)
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x52d332
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm0
movss %xmm3, 0x4(%rsp)
movq 0x40(%rdi), %rax
movss 0x2e26c(%rip), %xmm4 # 0x55b5b0
movaps %xmm4, %xmm2
testq %rax, %rax
je 0x52d355
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm2
movq 0x48(%rdi), %rax
movaps %xmm4, %xmm3
testq %rax, %rax
je 0x52d36a
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm3
movaps %xmm3, 0xc0(%rsp)
movaps %xmm2, 0xd0(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm5, 0x50(%rsp)
movq 0x50(%rdi), %rax
movaps %xmm4, %xmm1
testq %rax, %rax
je 0x52d399
movq 0x10(%rax), %rax
movss 0x8(%rax), %xmm1
movss %xmm1, 0x2c(%rsp)
movss %xmm0, (%rsp)
callq 0x1a5c40
movaps %xmm0, 0x80(%rsp)
movss (%rsp), %xmm0
callq 0x1a50c0
movss %xmm0, 0x28(%rsp)
movss 0x4(%rsp), %xmm0
callq 0x1a5c40
movss %xmm0, 0x8(%rsp)
movss 0x4(%rsp), %xmm0
callq 0x1a50c0
movss %xmm0, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
callq 0x1a5c40
movss %xmm0, (%rsp)
movss 0x10(%rsp), %xmm0
callq 0x1a50c0
xorps %xmm5, %xmm5
movss (%rsp), %xmm1
movaps %xmm1, %xmm7
addss %xmm5, %xmm7
movaps %xmm0, %xmm2
mulss 0x33090(%rip), %xmm2 # 0x5604a8
addss %xmm2, %xmm7
movaps %xmm2, %xmm4
movaps %xmm0, %xmm8
addss %xmm5, %xmm8
movaps %xmm1, %xmm3
mulss %xmm5, %xmm3
addss %xmm3, %xmm8
movaps %xmm3, %xmm9
addss %xmm5, %xmm9
addss %xmm9, %xmm4
movaps %xmm4, %xmm12
movss %xmm4, 0x4(%rsp)
subss %xmm0, %xmm9
mulss %xmm5, %xmm0
addss %xmm5, %xmm0
addss %xmm0, %xmm3
movaps %xmm3, 0x10(%rsp)
addss %xmm1, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps 0x30(%rsp), %xmm1
movaps %xmm1, %xmm0
movaps %xmm1, %xmm10
mulss %xmm5, %xmm0
addss %xmm0, %xmm7
addss %xmm0, %xmm8
addss %xmm5, %xmm0
movaps %xmm0, %xmm1
mulss %xmm5, %xmm1
movaps %xmm1, %xmm2
addss %xmm7, %xmm2
movaps %xmm0, %xmm6
movss 0x8(%rsp), %xmm4
mulss %xmm4, %xmm6
mulss %xmm5, %xmm7
addss %xmm7, %xmm6
movss 0xc(%rsp), %xmm3
movaps %xmm3, %xmm14
mulss %xmm8, %xmm14
addss %xmm6, %xmm14
addss %xmm5, %xmm10
movaps %xmm10, 0x30(%rsp)
movaps %xmm8, %xmm6
mulss %xmm5, %xmm6
addss %xmm6, %xmm2
mulss %xmm5, %xmm10
addss %xmm10, %xmm2
movaps %xmm2, 0xb0(%rsp)
addss %xmm10, %xmm14
mulss %xmm3, %xmm0
movaps %xmm7, %xmm10
subss %xmm0, %xmm10
mulss %xmm4, %xmm8
addss %xmm10, %xmm8
addss %xmm1, %xmm7
addss %xmm6, %xmm7
movaps 0x40(%rsp), %xmm15
movaps %xmm15, %xmm13
mulss %xmm5, %xmm13
movaps %xmm13, %xmm10
addss %xmm12, %xmm10
movaps %xmm13, %xmm6
movss 0x2e080(%rip), %xmm0 # 0x55b5b0
addss %xmm0, %xmm6
addss 0x10(%rsp), %xmm13
movaps %xmm6, %xmm0
mulss %xmm5, %xmm0
movaps %xmm0, %xmm3
addss %xmm10, %xmm3
movaps %xmm3, %xmm2
movaps %xmm6, %xmm11
movaps %xmm4, %xmm1
mulss %xmm4, %xmm11
mulss %xmm5, %xmm10
addss %xmm10, %xmm11
movss 0xc(%rsp), %xmm4
movaps %xmm4, %xmm3
mulss %xmm13, %xmm3
addss %xmm11, %xmm3
addss %xmm5, %xmm15
movaps %xmm15, 0x40(%rsp)
movaps %xmm13, %xmm11
mulss %xmm5, %xmm11
addss %xmm11, %xmm2
mulss %xmm5, %xmm15
addss %xmm15, %xmm2
movaps %xmm2, 0xa0(%rsp)
addss %xmm15, %xmm3
mulss %xmm4, %xmm6
movaps %xmm4, %xmm2
movaps %xmm10, %xmm15
subss %xmm6, %xmm15
movaps %xmm1, %xmm4
mulss %xmm1, %xmm13
addss %xmm15, %xmm13
addss %xmm0, %xmm10
addss %xmm11, %xmm10
movaps 0x50(%rsp), %xmm0
movaps %xmm0, %xmm11
movaps %xmm0, %xmm12
mulss %xmm5, %xmm11
addss %xmm11, %xmm9
movaps 0x70(%rsp), %xmm0
addss %xmm11, %xmm0
addss %xmm5, %xmm11
movaps %xmm11, %xmm6
mulss %xmm5, %xmm6
movaps %xmm6, %xmm1
addss %xmm9, %xmm1
movaps %xmm1, 0x60(%rsp)
movaps %xmm11, %xmm15
mulss %xmm4, %xmm15
mulss %xmm5, %xmm9
addss %xmm9, %xmm15
movaps %xmm2, %xmm4
mulss %xmm0, %xmm2
addss %xmm15, %xmm2
movaps %xmm12, %xmm1
addss %xmm5, %xmm1
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, %xmm15
movaps %xmm0, %xmm12
mulss %xmm5, %xmm15
movaps 0x60(%rsp), %xmm0
addss %xmm15, %xmm0
mulss %xmm5, %xmm1
addss %xmm1, %xmm0
movaps %xmm0, 0x60(%rsp)
addss %xmm1, %xmm2
movaps %xmm2, 0x90(%rsp)
movaps %xmm4, %xmm5
mulss %xmm4, %xmm11
movaps %xmm9, %xmm0
subss %xmm11, %xmm0
movss 0x8(%rsp), %xmm11
mulss %xmm11, %xmm12
addss %xmm0, %xmm12
movaps %xmm12, 0x70(%rsp)
addss %xmm6, %xmm9
addss %xmm15, %xmm9
movss %xmm9, 0x24(%rsp)
xorps %xmm2, %xmm2
movss 0x4(%rsp), %xmm4
addss %xmm2, %xmm4
movaps 0x10(%rsp), %xmm9
addss %xmm2, %xmm9
movaps %xmm9, %xmm0
mulss %xmm2, %xmm0
movaps %xmm0, %xmm6
addss %xmm4, %xmm6
movss %xmm6, (%rsp)
movaps %xmm11, %xmm6
mulss %xmm2, %xmm6
mulss %xmm2, %xmm4
xorps %xmm1, %xmm1
addss %xmm4, %xmm6
movaps %xmm5, %xmm2
movaps %xmm5, %xmm15
mulss %xmm9, %xmm15
addss %xmm6, %xmm15
mulss 0x32db3(%rip), %xmm2 # 0x5604a8
mulss %xmm11, %xmm9
movaps %xmm4, %xmm5
addss %xmm4, %xmm2
addss %xmm2, %xmm9
movaps %xmm9, 0x10(%rsp)
addss %xmm1, %xmm5
addss %xmm0, %xmm5
addss 0x2de94(%rip), %xmm5 # 0x55b5b0
movss %xmm5, 0x4(%rsp)
movss 0x28(%rsp), %xmm6
movaps %xmm6, %xmm0
mulss %xmm14, %xmm0
movaps 0x80(%rsp), %xmm2
movaps %xmm2, %xmm9
movaps 0xb0(%rsp), %xmm12
mulss %xmm12, %xmm9
addss %xmm0, %xmm9
movaps %xmm2, %xmm11
movaps %xmm2, %xmm5
mulss %xmm14, %xmm11
movaps %xmm6, %xmm0
movaps %xmm6, %xmm2
mulss %xmm12, %xmm0
subss %xmm0, %xmm11
mulss %xmm1, %xmm14
unpcklps %xmm14, %xmm8 # xmm8 = xmm8[0],xmm14[0],xmm8[1],xmm14[1]
movaps 0x30(%rsp), %xmm14
addss %xmm14, %xmm7
unpcklps %xmm12, %xmm14 # xmm14 = xmm14[0],xmm12[0],xmm14[1],xmm12[1]
xorps %xmm0, %xmm0
mulps %xmm0, %xmm14
addps %xmm8, %xmm14
movaps %xmm14, %xmm0
mulss %xmm1, %xmm0
addss %xmm0, %xmm9
addss %xmm0, %xmm11
movaps %xmm14, %xmm6
shufps $0x55, %xmm14, %xmm6 # xmm6 = xmm6[1,1],xmm14[1,1]
addss %xmm6, %xmm14
addss %xmm0, %xmm6
addss %xmm7, %xmm6
movaps %xmm6, 0x30(%rsp)
mulss %xmm1, %xmm7
addss %xmm7, %xmm9
addss %xmm7, %xmm11
addss %xmm7, %xmm14
movaps %xmm2, %xmm0
mulss %xmm3, %xmm0
movaps %xmm5, %xmm7
movaps 0xa0(%rsp), %xmm6
mulss %xmm6, %xmm7
addss %xmm0, %xmm7
movaps %xmm5, %xmm12
mulss %xmm3, %xmm12
movaps %xmm2, %xmm0
mulss %xmm6, %xmm0
subss %xmm0, %xmm12
mulss %xmm1, %xmm3
unpcklps %xmm3, %xmm13 # xmm13 = xmm13[0],xmm3[0],xmm13[1],xmm3[1]
movaps 0x40(%rsp), %xmm3
addss %xmm3, %xmm10
unpcklps %xmm6, %xmm3 # xmm3 = xmm3[0],xmm6[0],xmm3[1],xmm6[1]
mulps 0x2db87(%rip), %xmm3 # 0x55b3a0
addps %xmm13, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm13
mulss %xmm1, %xmm0
addss %xmm0, %xmm7
addss %xmm0, %xmm12
shufps $0x55, %xmm3, %xmm3 # xmm3 = xmm3[1,1,1,1]
addss %xmm3, %xmm13
addss %xmm0, %xmm3
addss %xmm10, %xmm3
movaps %xmm3, 0x40(%rsp)
mulss %xmm1, %xmm10
addss %xmm10, %xmm7
addss %xmm10, %xmm12
addss %xmm10, %xmm13
movaps %xmm2, %xmm0
movaps 0x90(%rsp), %xmm4
mulss %xmm4, %xmm0
movaps %xmm5, %xmm6
movaps %xmm5, %xmm8
movaps 0x60(%rsp), %xmm3
mulss %xmm3, %xmm8
addss %xmm0, %xmm8
movaps %xmm5, %xmm10
mulss %xmm4, %xmm10
movaps %xmm2, %xmm0
mulss %xmm3, %xmm0
movaps %xmm3, %xmm5
subss %xmm0, %xmm10
mulss %xmm1, %xmm4
movaps 0x70(%rsp), %xmm0
unpcklps %xmm4, %xmm0 # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movaps 0x50(%rsp), %xmm3
movss 0x24(%rsp), %xmm4
addss %xmm3, %xmm4
unpcklps %xmm5, %xmm3 # xmm3 = xmm3[0],xmm5[0],xmm3[1],xmm5[1]
mulps 0x2dae2(%rip), %xmm3 # 0x55b3a0
addps %xmm0, %xmm3
movaps %xmm3, %xmm0
mulss %xmm1, %xmm0
addss %xmm0, %xmm8
addss %xmm0, %xmm10
movaps %xmm3, %xmm1
shufps $0x55, %xmm3, %xmm1 # xmm1 = xmm1[1,1],xmm3[1,1]
addss %xmm1, %xmm3
addss %xmm0, %xmm1
movaps %xmm4, %xmm5
addss %xmm4, %xmm1
movaps %xmm1, 0x50(%rsp)
xorps %xmm0, %xmm0
mulss %xmm0, %xmm5
addss %xmm5, %xmm8
addss %xmm5, %xmm10
addss %xmm5, %xmm3
movss (%rsp), %xmm4
addss %xmm0, %xmm4
addss %xmm0, %xmm15
movaps %xmm2, %xmm1
mulss %xmm15, %xmm1
movaps %xmm6, %xmm0
mulss %xmm4, %xmm0
addss %xmm1, %xmm0
mulss %xmm15, %xmm6
mulss %xmm4, %xmm2
subss %xmm2, %xmm6
xorps %xmm1, %xmm1
mulss %xmm1, %xmm15
mulss %xmm1, %xmm4
addss %xmm15, %xmm4
movaps 0x10(%rsp), %xmm15
addss %xmm1, %xmm15
xorps %xmm2, %xmm2
movaps %xmm15, %xmm1
mulss %xmm2, %xmm1
addss %xmm1, %xmm0
addss %xmm1, %xmm6
addss %xmm4, %xmm15
addss %xmm1, %xmm4
movss 0x4(%rsp), %xmm1
addss %xmm1, %xmm4
movss %xmm4, (%rsp)
movaps %xmm1, %xmm4
mulss %xmm2, %xmm4
addss %xmm4, %xmm0
addss %xmm4, %xmm6
movaps %xmm6, 0x80(%rsp)
addss %xmm4, %xmm15
movsd 0xc0(%rsp), %xmm1
xorps %xmm5, %xmm5
shufps $0xe2, %xmm5, %xmm1 # xmm1 = xmm1[2,0],xmm5[2,3]
movaps 0xd0(%rsp), %xmm2
movss %xmm2, %xmm5 # xmm5 = xmm2[0],xmm5[1,2,3]
movaps %xmm5, 0x10(%rsp)
shufps $0x0, %xmm11, %xmm11 # xmm11 = xmm11[0,0,0,0]
mulps %xmm1, %xmm11
movaps %xmm9, %xmm4
unpcklps %xmm9, %xmm4 # xmm4 = xmm4[0],xmm9[0],xmm4[1],xmm9[1]
mulps %xmm5, %xmm4
addps %xmm11, %xmm4
movss 0x2c(%rsp), %xmm6
movaps %xmm6, %xmm2
mulss %xmm14, %xmm2
mulss 0x2dc55(%rip), %xmm14 # 0x55b638
movaps %xmm14, %xmm5
unpcklps %xmm14, %xmm5 # xmm5 = xmm5[0],xmm14[0],xmm5[1],xmm14[1]
addps %xmm4, %xmm5
xorps %xmm4, %xmm4
mulss %xmm4, %xmm9
addss %xmm11, %xmm9
addss %xmm9, %xmm2
addss %xmm14, %xmm9
movaps 0x30(%rsp), %xmm14
addss %xmm14, %xmm9
mulss %xmm4, %xmm14
addss %xmm14, %xmm2
unpcklps %xmm14, %xmm14 # xmm14 = xmm14[0,0,1,1]
addps %xmm5, %xmm14
movlps %xmm14, (%rbx)
movss %xmm2, 0x8(%rbx)
movss %xmm9, 0xc(%rbx)
shufps $0x0, %xmm12, %xmm12 # xmm12 = xmm12[0,0,0,0]
mulps %xmm1, %xmm12
movaps %xmm7, %xmm4
unpcklps %xmm7, %xmm4 # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1]
movaps 0x10(%rsp), %xmm11
mulps %xmm11, %xmm4
addps %xmm12, %xmm4
movaps %xmm6, %xmm2
mulss %xmm13, %xmm2
xorps %xmm9, %xmm9
mulss %xmm9, %xmm13
movaps %xmm13, %xmm5
unpcklps %xmm13, %xmm5 # xmm5 = xmm5[0],xmm13[0],xmm5[1],xmm13[1]
addps %xmm4, %xmm5
mulss %xmm9, %xmm7
addss %xmm12, %xmm7
addss %xmm7, %xmm2
addss %xmm13, %xmm7
movaps 0x40(%rsp), %xmm13
addss %xmm13, %xmm7
mulss %xmm9, %xmm13
addss %xmm13, %xmm2
unpcklps %xmm13, %xmm13 # xmm13 = xmm13[0,0,1,1]
addps %xmm5, %xmm13
movlps %xmm13, 0x10(%rbx)
movss %xmm2, 0x18(%rbx)
movss %xmm7, 0x1c(%rbx)
shufps $0x0, %xmm10, %xmm10 # xmm10 = xmm10[0,0,0,0]
mulps %xmm1, %xmm10
movaps %xmm8, %xmm4
unpcklps %xmm8, %xmm4 # xmm4 = xmm4[0],xmm8[0],xmm4[1],xmm8[1]
mulps %xmm11, %xmm4
addps %xmm10, %xmm4
movaps %xmm6, %xmm2
mulss %xmm3, %xmm2
mulss %xmm9, %xmm3
movaps %xmm3, %xmm5
unpcklps %xmm3, %xmm5 # xmm5 = xmm5[0],xmm3[0],xmm5[1],xmm3[1]
addps %xmm4, %xmm5
mulss %xmm9, %xmm8
addss %xmm10, %xmm8
addss %xmm8, %xmm2
addss %xmm3, %xmm8
movaps 0x50(%rsp), %xmm3
addss %xmm3, %xmm8
mulss %xmm9, %xmm3
addss %xmm3, %xmm2
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
addps %xmm5, %xmm3
movlps %xmm3, 0x20(%rbx)
movss %xmm2, 0x28(%rbx)
movss %xmm8, 0x2c(%rbx)
movaps 0x80(%rsp), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
mulps %xmm1, %xmm2
movaps %xmm0, %xmm1
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm11, %xmm1
addps %xmm2, %xmm1
xorps %xmm3, %xmm3
mulss %xmm3, %xmm0
addss %xmm2, %xmm0
movaps %xmm6, %xmm2
mulss %xmm15, %xmm2
mulss %xmm3, %xmm15
xorps %xmm4, %xmm4
addss %xmm0, %xmm2
movaps %xmm2, %xmm3
addss %xmm15, %xmm0
movaps %xmm15, %xmm2
unpcklps %xmm15, %xmm2 # xmm2 = xmm2[0],xmm15[0],xmm2[1],xmm15[1]
addps %xmm1, %xmm2
movss (%rsp), %xmm1
addss %xmm1, %xmm0
mulss %xmm4, %xmm1
addss %xmm1, %xmm3
unpcklps %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1]
addps %xmm2, %xmm1
movlps %xmm1, 0x30(%rbx)
movss %xmm3, 0x38(%rbx)
jmp 0x52dba7
movl $0x3f800000, %eax # imm = 0x3F800000
movl %eax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movl %eax, 0x14(%rbx)
movups %xmm0, 0x18(%rbx)
movl %eax, 0x28(%rbx)
movups %xmm0, 0x2c(%rbx)
movss 0x2da09(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0x3c(%rbx)
addq $0xe0, %rsp
popq %rbx
retq
nop
| /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
#ifndef AI_BUILD_BIG_ENDIAN
while (cursor < end)ByteSwap::Swap2(cursor++);
cursor = (LE_NCONST uint16_t*)mFileBuffer;
#endif
unsigned int iNumFaces = 0,iNumVertices = 0;
CountVertsAndFacesLWOB(iNumVertices,iNumFaces,cursor,end);
// allocate the output array and copy face indices
if (iNumFaces)
{
cursor = (LE_NCONST uint16_t*)mFileBuffer;
mCurLayer->mFaces.resize(iNumFaces);
FaceList::iterator it = mCurLayer->mFaces.begin();
CopyFaceIndicesLWOB(it,cursor,end);
}
} | 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
leaq 0x14(%rsp), %r15
movl %eax, (%r15)
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %r8
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
callq 0x52fd7a
movl (%r15), %esi
testq %rsi, %rsi
je 0x52f1b2
movq 0xd8(%r14), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movl $0x100, %edi # imm = 0x100
addq 0x88(%r14), %rdi
callq 0x5303e2
movq 0x88(%r14), %rax
movq 0x100(%rax), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
callq 0x52ff2c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x70a7c(%rip), %rdi # 0x59fc3f
leaq 0x70a7c(%rip), %rsi # 0x59fc46
leaq 0xadf33(%rip), %rcx # 0x5dd104
movl $0x4e, %edx
callq 0x1a5270
nop
| /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 < 2) {
throw DeadlyImportError("LWOB: Unexpected end of file");
}
::memcpy(&numIndices, cursor++, 2);
// must have enough left for indices and surface
if (end - cursor < (1 + numIndices)) {
throw DeadlyImportError("LWOB: Unexpected end of file");
}
verts += numIndices;
faces++;
cursor += numIndices;
int16_t surface;
::memcpy(&surface, cursor++, 2);
if (surface < 0)
{
// there are detail polygons
::memcpy(&numIndices, cursor++, 2);
CountVertsAndFacesLWOB(verts,faces,cursor,end,numIndices);
}
}
} | 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
leaq 0x2(%rax), %rcx
movq %rcx, (%r15)
movzwl (%rax), %eax
movq %r14, %rdx
subq %rcx, %rdx
sarq %rdx
leaq 0x1(%rax), %rcx
cmpq %rcx, %rdx
jl 0x52fe32
addl %eax, (%r13)
incl (%r12)
movq (%r15), %rcx
movl %eax, %edx
leaq (%rcx,%rdx,2), %rax
addq $0x2, %rax
movq %rax, (%r15)
cmpw $0x0, -0x2(%rax)
jns 0x52fe1e
leaq (%rcx,%rdx,2), %rax
leaq 0x4(%rax), %rcx
movq %rcx, (%r15)
movzwl 0x2(%rax), %r9d
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x52fd7a
movq (%r15), %rax
cmpq %r14, %rax
jb 0x52fda8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xad0e6(%rip), %rsi # 0x5dcf35
leaq 0xad0fb(%rip), %rdx # 0x5dcf51
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x1ad8c1(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1ad88d(%rip), %rsi # 0x6dd710
movq 0x27c0d6(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x52fef4
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xad084(%rip), %rsi # 0x5dcf35
leaq 0xad099(%rip), %rdx # 0x5dcf51
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a53e0
leaq 0x1ad85f(%rip), %rax # 0x6dd738
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1ad82b(%rip), %rsi # 0x6dd710
movq 0x27c074(%rip), %rdx # 0x7abf60
movq %rbx, %rdi
callq 0x1a5b00
jmp 0x52fef8
jmp 0x52ff19
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x52ff12
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x52ff1c
jmp 0x52ff24
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6080
movq %r14, %rdi
callq 0x1a5b90
| /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.mNumIndices = numIndices;
if(face.mNumIndices)
{
if (cursor + face.mNumIndices >= end)
{
break;
}
face.mIndices = new unsigned int[face.mNumIndices];
for (unsigned int i = 0; i < face.mNumIndices;++i) {
unsigned int & mi = face.mIndices[i];
uint16_t index;
::memcpy(&index, cursor++, 2);
mi = index;
if (mi > mCurLayer->mTempPoints.size())
{
ASSIMP_LOG_WARN("LWOB: face index is out of range");
mi = (unsigned int)mCurLayer->mTempPoints.size()-1;
}
}
} else {
ASSIMP_LOG_WARN("LWOB: Face has 0 indices");
}
int16_t surface;
::memcpy(&surface, cursor++, 2);
if (surface < 0)
{
surface = -surface;
// there are detail polygons.
uint16_t numPolygons;
::memcpy(&numPolygons, cursor++, 2);
if (cursor < end)
{
CopyFaceIndicesLWOB(it,cursor,end,numPolygons);
}
}
face.surfaceIndex = surface-1;
}
} | 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
movq (%rcx), %r14
leaq 0x20(%r14), %rax
movq %rax, (%rcx)
movq (%r15), %rax
leaq 0x2(%rax), %rcx
movq %rcx, (%r15)
movzwl (%rax), %edi
movl %edi, (%r14)
testl %edi, %edi
movl %r8d, 0x4(%rsp)
je 0x53002a
leal (%rdi,%rdi), %eax
addq (%r15), %rax
cmpq %rbp, %rax
jae 0x53009d
shll $0x2, %edi
callq 0x1a57a0
movq %rax, 0x8(%r14)
cmpl $0x0, (%r14)
je 0x53003e
xorl %ebp, %ebp
movq 0x8(%r14), %rbx
movq (%r15), %rax
leaq 0x2(%rax), %rcx
movq %rcx, (%r15)
movzwl (%rax), %eax
movl %eax, (%rbx,%rbp,4)
movq 0x88(%r13), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x2, %rdx
imulq %r12, %rdx
cmpq %rax, %rdx
jae 0x53001d
callq 0x241234
movq %rax, %rdi
leaq 0xacf57(%rip), %rsi # 0x5dcf52
callq 0x241182
movq 0x88(%r13), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x2, %rcx
imull $0xaaaaaaab, %ecx, %eax # imm = 0xAAAAAAAB
decl %eax
movl %eax, (%rbx,%rbp,4)
incq %rbp
movl (%r14), %eax
cmpq %rax, %rbp
jb 0x52ffbd
jmp 0x53003e
callq 0x241234
movq %rax, %rdi
leaq 0xacf3a(%rip), %rsi # 0x5dcf73
callq 0x241182
movq (%r15), %rcx
leaq 0x2(%rcx), %rax
movq %rax, (%r15)
movzwl (%rcx), %ebx
testw %bx, %bx
js 0x53005c
movl 0x4(%rsp), %r8d
movq 0x8(%rsp), %rbp
jmp 0x53008b
negl %ebx
addq $0x4, %rcx
movq %rcx, (%r15)
movq 0x8(%rsp), %rbp
cmpq %rbp, %rcx
jae 0x530086
movzwl (%rax), %r8d
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x52ff2c
movl 0x4(%rsp), %r8d
movswl %bx, %eax
decl %eax
movl %eax, 0x10(%r14)
cmpq %rbp, (%r15)
jb 0x52ff60
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 ( numToken == 1 ) {
name = AI_DEFAULT_MATERIAL_NAME;
} else {
// skip newmtl and all following white spaces
std::size_t first_ws_pos = line.find_first_of(" \t");
std::size_t first_non_ws_pos = line.find_first_not_of(" \t", first_ws_pos);
if (first_non_ws_pos != std::string::npos) {
name = line.substr(first_non_ws_pos);
}
}
name = trim_whitespaces(name);
std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( name );
if ( m_pModel->m_MaterialMap.end() == it) {
// New Material created
m_pModel->m_pCurrentMaterial = new ObjFile::Material();
m_pModel->m_pCurrentMaterial->MaterialName.Set( name );
m_pModel->m_MaterialLib.push_back( name );
m_pModel->m_MaterialMap[ name ] = m_pModel->m_pCurrentMaterial;
if (m_pModel->m_pCurrentMesh) {
m_pModel->m_pCurrentMesh->m_uiMaterialIndex = static_cast<unsigned int>(m_pModel->m_MaterialLib.size() - 1);
}
} else {
// Use older material
m_pModel->m_pCurrentMaterial = (*it).second;
}
} | 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
movzbl (%rax), %eax
cmpl $0xd, %eax
ja 0x53155b
btl %eax, %ebp
jb 0x531573
movsbl %al, %esi
movq %r14, %rdi
callq 0x1a6540
movq 0x20(%rbx), %rax
incq %rax
movq %rax, 0x20(%rbx)
jmp 0x53154e
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x775a5(%rip), %rsi # 0x5a8b3f
leaq 0x775a0(%rip), %rdx # 0x5a8b41
movq %rsp, %rdi
callq 0x209290
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %rsp, %rdx
callq 0x531f44
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5315d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x7755e(%rip), %rdx # 0x5a8b41
movq %rdx, %rsi
callq 0x209290
cmpl $0x1, %ebp
jne 0x53160d
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x5e32b(%rip), %rcx # 0x58f929
movl $0xf, %r8d
xorl %esi, %esi
callq 0x1a5830
jmp 0x531687
leaq 0x7752b(%rip), %r14 # 0x5a8b3f
leaq 0x20(%rsp), %r15
movl $0x2, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a52a0
movl $0x2, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1a5ea0
cmpq $-0x1, %rax
je 0x531687
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x1a6240
movq %rsp, %rdi
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x1a58d0
movq (%r14), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x531687
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x20ac60
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x314b02
movq %rsp, %rdi
leaq 0x40(%rsp), %r14
movq %r14, %rsi
callq 0x1a58d0
movq (%r14), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5316df
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x5316f6
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x148, %edi # imm = 0x148
addq 0x30(%rbx), %rdi
movq %rsp, %rsi
callq 0x3156d4
movq 0x30(%rbx), %rcx
leaq 0x150(%rcx), %rdx
cmpq %rax, %rdx
je 0x531724
movq 0x40(%rax), %rax
movq %rax, 0x40(%rcx)
jmp 0x5317bb
movl $0x409c, %edi # imm = 0x409C
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x31454c
movq 0x30(%rbx), %rax
movq %r14, 0x40(%rax)
movq 0x8(%rsp), %r14
cmpq $0x3ff, %r14 # imm = 0x3FF
ja 0x531770
movq 0x30(%rbx), %rax
movq 0x40(%rax), %r15
movl %r14d, (%r15)
leaq 0x4(%r15), %rdi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x1a5110
movb $0x0, 0x4(%r15,%r14)
movq 0x30(%rbx), %rdi
addq $0x50, %rdi
movq %rsp, %rsi
callq 0x23e828
movq 0x30(%rbx), %rdi
movq 0x40(%rdi), %r14
addq $0x148, %rdi # imm = 0x148
movq %rsp, %rsi
callq 0x31475c
movq %r14, (%rax)
movq 0x30(%rbx), %rcx
movq 0x128(%rcx), %rax
testq %rax, %rax
je 0x5317bb
movq 0x58(%rcx), %rdx
subq 0x50(%rcx), %rdx
shrq $0x5, %rdx
decl %edx
movl %edx, 0x64(%rax)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5317d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x80(%rsp), %rdi
callq 0x23c89e
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5317f5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53183f
movq %rax, %rbx
movl $0x409c, %esi # imm = 0x409C
movq %r14, %rdi
jmp 0x53182d
jmp 0x53183f
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x531842
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x531842
jmp 0x53183f
jmp 0x53183a
jmp 0x53183f
movq %rax, %rbx
jmp 0x531858
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x531858
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a5190
leaq 0x80(%rsp), %rdi
callq 0x23c89e
jmp 0x53186a
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x531881
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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 );
m_pModel->m_Lumps[ idx ] = pLump;
}
} | 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, (%rcx,%r15,8)
incq %r15
cmpq $0x11, %r15
jne 0x53231c
popq %rbx
popq %r14
popq %r15
retq
nop
| /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_Data[ Offset ], lump->iSize );
} | 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), %rdx
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1a5110
leaq 0xab011(%rip), %rdi # 0x5dd514
leaq 0xaaf2b(%rip), %rsi # 0x5dd435
leaq 0xab017(%rip), %rcx # 0x5dd528
movl $0xce, %edx
callq 0x1a5270
nop
| /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 ) );
m_pModel->m_Faces[ idx ] = pFace;
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, %r14
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movl $0x68, %edx
movq %rax, %rdi
callq 0x1a5110
movq (%r15), %rax
movq %r14, (%rax,%r13,8)
addq $0x68, %r12
incq %r13
movq 0x20(%rbx), %rax
leaq 0x48(%rax), %r15
movq 0x50(%rax), %rcx
subq 0x48(%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x53254d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xaaf6e(%rip), %rdi # 0x5dd514
leaq 0xaae88(%rip), %rsi # 0x5dd435
leaq 0xaaf9f(%rip), %rcx # 0x5dd553
movl $0xda, %edx
callq 0x1a5270
| /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(sQ3BSPTexture) );
m_pModel->m_Textures[ idx ] = pTexture;
Offset += sizeof(sQ3BSPTexture);
}
} | 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, %r14
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movl $0x48, %edx
movq %rax, %rdi
callq 0x1a5110
movq (%r15), %rax
movq %r14, (%rax,%r13,8)
addq $0x48, %r12
incq %r13
movq 0x20(%rbx), %rax
leaq 0x78(%rax), %r15
movq 0x80(%rax), %rcx
subq 0x78(%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jb 0x5325f2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xaaec6(%rip), %rdi # 0x5dd514
leaq 0xaade0(%rip), %rsi # 0x5dd435
leaq 0xaaf20(%rip), %rcx # 0x5dd57c
movl $0xe9, %edx
callq 0x1a5270
| /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 ];
}
for ( unsigned int i=0; i<m_Textures.size(); i++ ) {
delete m_Textures[ i ];
}
for ( unsigned int i=0; i<m_Lightmaps.size(); i++ ) {
delete m_Lightmaps[ i ];
}
m_Lumps.clear();
m_Vertices.clear();
m_Faces.clear();
m_Textures.clear();
m_Lightmaps.clear();
} | 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 0x5328a3
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x532900
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
movl $0x2c, %esi
callq 0x1a5190
movl %ebp, %ecx
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x5328da
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x532937
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
movl $0x68, %esi
callq 0x1a5190
movl %ebp, %ecx
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x532911
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x532974
movl $0x1, %ebp
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdi
movl $0x48, %esi
callq 0x1a5190
movl %ebp, %ecx
movq 0x78(%rbx), %rax
movq 0x80(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %ebp
cmpq %rcx, %rdx
ja 0x53294b
movq 0x90(%rbx), %rax
movq 0x98(%rbx), %rcx
cmpq %rax, %rcx
je 0x5329bd
movl $0x1, %ebp
xorl %edx, %edx
movq (%rax,%rdx,8), %rdi
movl $0xc000, %esi # imm = 0xC000
callq 0x1a5190
movl %ebp, %edx
movq 0x90(%rbx), %rax
movq 0x98(%rbx), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
incl %ebp
cmpq %rdx, %rsi
ja 0x53298e
movq 0x18(%rbx), %rdx
cmpq %rdx, 0x20(%rbx)
je 0x5329cb
movq %rdx, 0x20(%rbx)
movq 0x30(%rbx), %rdx
cmpq %rdx, 0x38(%rbx)
je 0x5329d9
movq %rdx, 0x38(%rbx)
movq 0x48(%rbx), %rdx
cmpq %rdx, 0x50(%rbx)
je 0x5329e7
movq %rdx, 0x50(%rbx)
movq 0x78(%rbx), %rdx
cmpq %rdx, 0x80(%rbx)
je 0x5329fb
movq %rdx, 0x80(%rbx)
cmpq %rax, %rcx
je 0x532a07
movq %rax, 0x98(%rbx)
movq 0xc0(%rbx), %rdi
leaq 0xd0(%rbx), %rax
cmpq %rax, %rdi
je 0x532a25
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x532a40
movq 0xb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x532a5b
movq 0xa0(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x532a73
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x532a88
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x532a9d
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x532ab2
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x532ac7
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x532ae1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a5190
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /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_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_RET("closureType", closureType, mReader->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("endAngle", endAngle, XML_ReadNode_GetAttrVal_AsFloat);
MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("startAngle", startAngle, XML_ReadNode_GetAttrVal_AsFloat);
MACRO_ATTRREAD_LOOPEND;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_ArcClose2D, ne);
}
else
{
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_ArcClose2D, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
((CX3DImporter_NodeElement_Geometry2D*)ne)->Solid = solid;
// create point list of geometry object.
GeometryHelper_Make_Arc2D(startAngle, endAngle, radius, 10, ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices);///TODO: IME - AI_CONFIG for NumSeg
// add chord or two radiuses only if not a circle was defined
if(!((std::fabs(endAngle - startAngle) >= AI_MATH_TWO_PI_F) || (endAngle == startAngle)))
{
std::list<aiVector3D>& vlist = ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices;// just short alias.
if((closureType == "PIE") || (closureType == "\"PIE\""))
vlist.push_back(aiVector3D(0, 0, 0));// center point - first radial line
else if((closureType != "CHORD") && (closureType != "\"CHORD\""))
Throw_IncorrectAttrValue("closureType");
vlist.push_back(*vlist.begin());// arc first point - chord from first to last point of arc(if CHORD) or second radial line(if PIE).
}
((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices.size();
// check for X3DMetadataObject childs.
if(!mReader->isEmptyElement())
ParseNode_Metadata(ne, "ArcClose2D");
else
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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, -0x10(%rax)
leaq 0xa9d96(%rip), %rsi # 0x5dd5d5
leaq 0xa9d92(%rip), %rdx # 0x5dd5d8
leaq 0x40(%rsp), %rdi
callq 0x209290
movq $0x0, 0x38(%rsp)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
xorl %r14d, %r14d
testl %eax, %eax
movq %rbx, (%rsp)
jle 0x533ab2
movss 0x2f835(%rip), %xmm0 # 0x5630b4
movss %xmm0, 0xc(%rsp)
movss 0x27d23(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %r12
movq $0x0, 0x60(%rsp)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x28(%rax)
movq %r12, %rdi
movq %rax, %rsi
leaq 0x17(%rsp), %rdx
callq 0x23ca1c
movq %r12, %rdi
leaq 0x9ec29(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x5339bd
movq %r12, %rdi
leaq 0x3793e(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x5339da
movq %r12, %rdi
leaq 0x9d038(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x533a15
movq %r12, %rdi
leaq 0x9d02c(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x533a15
movq %r12, %rdi
leaq 0x9d01e(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x533a15
movq %r12, %rdi
leaq 0x9e8c5(%rip), %rsi # 0x5d220c
callq 0x1a60c0
testl %eax, %eax
je 0x533a3f
movq %r12, %rdi
leaq 0x9e9e5(%rip), %rsi # 0x5d2343
callq 0x1a60c0
testl %eax, %eax
je 0x533a59
movq %r12, %rdi
leaq 0x76f9e(%rip), %rsi # 0x5aa913
callq 0x1a60c0
testl %eax, %eax
je 0x533a6c
movq %r12, %rdi
leaq 0x6ae7a(%rip), %rsi # 0x59e806
callq 0x1a60c0
testl %eax, %eax
je 0x533a7f
movq %r12, %rdi
leaq 0x9efd7(%rip), %rsi # 0x5d297a
callq 0x1a60c0
testl %eax, %eax
je 0x533a91
movq %rbx, %rdi
movq %r12, %rsi
callq 0x498b92
jmp 0x533a15
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x88(%rsp), %r15
jmp 0x5339f2
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x68(%rsp), %r15
movq 0x8(%r15), %rbx
movq %r13, %rdi
callq 0x1a56a0
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x1a5830
movq (%rsp), %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x533a31
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r14d
cmpl %r14d, %ebp
jne 0x5338aa
jmp 0x533aa7
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x40(%rsp), %r15
jmp 0x5339f2
movq %rbx, %rdi
movl %r14d, %esi
callq 0x49a228
movss %xmm0, 0xc(%rsp)
jmp 0x533a15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x49a228
movss %xmm0, 0x10(%rsp)
jmp 0x533a15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x499f12
movq %rax, 0x60(%rsp)
jmp 0x533a15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x49a228
movss %xmm0, 0x8(%rsp)
jmp 0x533a15
movq 0x60(%rsp), %r14
andb $0x1, %r14b
jmp 0x533ad7
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x27aed(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0x10(%rsp)
movss 0x2f5e3(%rip), %xmm0 # 0x5630b4
movss %xmm0, 0xc(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x533b64
movq %rbx, %rdi
callq 0x4997b6
cmpq $0x0, 0x90(%rsp)
je 0x533aff
movq (%rsp), %rdi
callq 0x4989dc
leaq 0x68(%rsp), %rsi
leaq 0x38(%rsp), %rcx
movq (%rsp), %rdi
movl $0x8, %edx
callq 0x498494
testb %al, %al
jne 0x533b29
leaq 0x68(%rsp), %rsi
movq (%rsp), %rdi
callq 0x4994f4
movq (%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, (%rsp)
movl $0x18, %edi
callq 0x1a5230
movq (%rsp), %rbx
leaq 0x38(%rbx), %rsi
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x48, %rbx
jmp 0x533dfc
movl $0x78, %edi
callq 0x1a5230
movq %rax, %r15
movq (%rsp), %rax
movq 0x90(%rax), %rax
movl $0x8, 0x8(%r15)
leaq 0x20(%r15), %rcx
movq %rcx, 0x10(%r15)
xorl %ecx, %ecx
movq %rcx, 0x18(%r15)
movb $0x0, 0x20(%r15)
movq %rax, 0x30(%r15)
leaq 0x38(%r15), %rax
movq %rax, 0x40(%r15)
movq %rax, 0x38(%r15)
movq %rcx, 0x48(%r15)
leaq 0x277c56(%rip), %rax # 0x7ab808
movq %rax, (%r15)
leaq 0x50(%r15), %r12
movq %r12, 0x58(%r15)
movq %r12, 0x50(%r15)
movq %rcx, 0x60(%r15)
movb $0x1, 0x70(%r15)
movq %r15, 0x38(%rsp)
cmpq %rcx, 0x90(%rsp)
je 0x533bed
movq %r15, %rdi
addq $0x10, %rdi
leaq 0x88(%rsp), %rsi
callq 0x1a64a0
movb %r14b, 0x70(%r15)
movl $0xa, %esi
movq (%rsp), %rdi
movss 0x8(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
movss 0x10(%rsp), %xmm2
movq %r12, %rdx
callq 0x49b960
movss 0xc(%rsp), %xmm1
movaps %xmm1, %xmm0
movss 0x8(%rsp), %xmm2
subss %xmm2, %xmm0
andps 0x276d2(%rip), %xmm0 # 0x55b300
ucomiss 0x2c89f(%rip), %xmm0 # 0x5604d4
jae 0x533cea
ucomiss %xmm2, %xmm1
jne 0x533c46
jnp 0x533cea
leaq 0xa9988(%rip), %rsi # 0x5dd5d5
leaq 0x40(%rsp), %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x533cf0
leaq 0xa9973(%rip), %rsi # 0x5dd5d9
leaq 0x40(%rsp), %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x533cf0
leaq 0xa9964(%rip), %rsi # 0x5dd5df
leaq 0x40(%rsp), %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x533d18
leaq 0xa9951(%rip), %rsi # 0x5dd5e5
leaq 0x40(%rsp), %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x533d18
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x9e55a(%rip), %rsi # 0x5d220c
leaq 0x9e55e(%rip), %rdx # 0x5d2217
leaq 0x18(%rsp), %rdi
callq 0x209290
leaq 0x18(%rsp), %rsi
movq (%rsp), %rdi
callq 0x498e54
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x533d18
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x533d18
movq 0x60(%r15), %rax
jmp 0x533d4a
movl $0x20, %edi
callq 0x1a5230
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5360
incq 0x60(%r15)
movq (%r12), %rbx
movl $0x20, %edi
callq 0x1a5230
movl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5360
movq 0x60(%r15), %rax
incq %rax
movq %rax, 0x60(%r15)
movq %rax, 0x68(%r15)
movq (%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x533d8e
movq (%rsp), %rax
movq 0x90(%rax), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r15, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x533dd7
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x9d342(%rip), %rsi # 0x5d10e0
leaq 0x9d345(%rip), %rdx # 0x5d10ea
leaq 0x18(%rsp), %rdi
callq 0x209290
movq (%rsp), %rdi
leaq 0x18(%rsp), %rdx
movq %r15, %rsi
callq 0x4a7412
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x533dd7
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x18, %edi
callq 0x1a5230
movq (%rsp), %rbx
leaq 0x78(%rbx), %rsi
movq %r15, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x88, %rbx
incq (%rbx)
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
leaq 0x98(%rsp), %rbx
leaq 0x78(%rsp), %r14
je 0x533e28
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x533e3f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x88(%rsp), %rdi
cmpq %rbx, %rdi
je 0x533e5c
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x533e74
jmp 0x533e92
jmp 0x533e92
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
jne 0x533ea9
jmp 0x533eb6
jmp 0x533e92
jmp 0x533e92
jmp 0x533e92
movq %rax, %rbx
jmp 0x533ed2
jmp 0x533e92
jmp 0x533e92
movq %rax, %rbx
jmp 0x533eb6
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x533eb6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x533ed2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x533eee
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x533f13
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_Circle2D, ne);
}
else
{
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Circle2D, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
// create point list of geometry object and convert it to line set.
std::list<aiVector3D> tlist;
GeometryHelper_Make_Arc2D(0, 0, radius, 10, tlist);///TODO: IME - AI_CONFIG for NumSeg
GeometryHelper_Extend_PointToLine(tlist, ((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices);
((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 2;
// check for X3DMetadataObject childs.
if(!mReader->isEmptyElement())
ParseNode_Metadata(ne, "Circle2D");
else
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
testl %eax, %eax
movq %rbx, 0x10(%rsp)
jle 0x5340c8
xorl %r14d, %r14d
movss 0x27634(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0xc(%rsp)
leaq 0x20(%rsp), %r15
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
leaq 0x80(%rsp), %rdx
callq 0x23ca1c
movq %r15, %rdi
leaq 0x9e549(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x534035
movq %r15, %rdi
leaq 0x37262(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x53404f
movq %r15, %rdi
leaq 0x9c960(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x53408b
movq %r15, %rdi
leaq 0x9c954(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x53408b
movq %r15, %rdi
leaq 0x9c946(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x53408b
movq %r15, %rdi
leaq 0x768f8(%rip), %rsi # 0x5aa913
callq 0x1a60c0
testl %eax, %eax
je 0x5340b5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x498b92
jmp 0x53408b
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x60(%rsp), %r13
jmp 0x534067
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x40(%rsp), %r13
movq 0x8(%r13), %rbx
movq %r12, %rdi
callq 0x1a56a0
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x1a5830
movq 0x10(%rsp), %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5340a7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r14d
cmpl %r14d, %ebp
jne 0x533f87
jmp 0x5340d6
movq %rbx, %rdi
movl %r14d, %esi
callq 0x49a228
movss %xmm0, 0xc(%rsp)
jmp 0x53408b
movss 0x274e0(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0xc(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x53414d
movq %rbx, %rdi
callq 0x4997b6
cmpq $0x0, 0x68(%rsp)
je 0x5340f6
movq %rbx, %rdi
callq 0x4989dc
leaq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rcx
movq %rbx, %rdi
movl $0x9, %edx
callq 0x498494
testb %al, %al
jne 0x53411e
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x4994f4
movq 0x90(%rbx), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x5342ec
movl $0x78, %edi
callq 0x1a5230
movq %rax, %r15
movq 0x90(%rbx), %rax
movl $0x9, 0x8(%r15)
leaq 0x20(%r15), %rcx
movq %rcx, 0x10(%r15)
xorl %ecx, %ecx
movq %rcx, 0x18(%r15)
movb $0x0, 0x20(%r15)
movq %rax, 0x30(%r15)
leaq 0x38(%r15), %rax
movq %rax, 0x40(%r15)
movq %rax, 0x38(%r15)
movq %rcx, 0x48(%r15)
leaq 0x277671(%rip), %rax # 0x7ab808
movq %rax, (%r15)
leaq 0x50(%r15), %r13
movq %r13, 0x58(%r15)
movq %r13, 0x50(%r15)
movq %rcx, 0x60(%r15)
movb $0x1, 0x70(%r15)
movq %r15, 0x18(%rsp)
cmpq %rcx, 0x68(%rsp)
je 0x5341cc
movq %r15, %rdi
addq $0x10, %rdi
leaq 0x60(%rsp), %rsi
callq 0x1a64a0
leaq 0x80(%rsp), %r14
movq %r14, 0x8(%r14)
movq %r14, (%r14)
movq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movl $0xa, %esi
movq %rbx, %rdi
movss 0xc(%rsp), %xmm2
movq %r14, %rdx
callq 0x49b960
leaq 0x80(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x49bbc2
movq $0x2, 0x68(%r15)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x53425a
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r15, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x5342a4
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x9ce81(%rip), %rsi # 0x5d10eb
leaq 0x9ce82(%rip), %rdx # 0x5d10f3
leaq 0x20(%rsp), %rdi
callq 0x209290
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r15, %rsi
callq 0x4a7412
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x5342a4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x18, %edi
callq 0x1a5230
movq 0x10(%rsp), %rbx
leaq 0x78(%rbx), %rsi
movq %r15, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x88(%rbx)
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0x5342ec
movq (%rdi), %rbx
movl $0x20, %esi
callq 0x1a5190
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0x5342d7
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x534308
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x534324
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x534359
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x534359
jmp 0x534356
jmp 0x534381
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r14, %rdi
je 0x5343a5
movq (%rdi), %r15
movl $0x20, %esi
callq 0x1a5190
movq %r15, %rdi
cmpq %r14, %r15
jne 0x534366
jmp 0x5343a5
jmp 0x534381
jmp 0x534381
movq %rax, %rbx
jmp 0x5343a5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5343a5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5343c1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x5343dd
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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_ATTRREAD_LOOPEND;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_Polypoint2D, ne);
}
else
{
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_Polypoint2D, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
// convert vec2 to vec3
for(std::list<aiVector2D>::iterator it2 = point.begin(); it2 != point.end(); ++it2)
{
((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices.push_back(aiVector3D(it2->x, it2->y, 0));
}
((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 1;
// check for X3DMetadataObject childs.
if(!mReader->isEmptyElement())
ParseNode_Metadata(ne, "Polypoint2D");
else
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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(%rcx)
movq %rcx, (%rcx)
movq %rax, 0x10(%rcx)
movq %rax, 0x10(%rsp)
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
testl %eax, %eax
jle 0x5353b2
xorl %r14d, %r14d
leaq 0x18(%rsp), %r15
movq %r13, 0x90(%rsp)
movq 0x98(%r13), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x23ca1c
movq %r15, %rdi
leaq 0x9d261(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x53531d
movq %r15, %rdi
leaq 0x35f7a(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x535337
movq %r15, %rdi
leaq 0x9b678(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x535376
movq %r15, %rdi
leaq 0x9b66c(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x535376
movq %r15, %rdi
leaq 0x9b65e(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x535376
movq %r15, %rdi
leaq 0x5dd07(%rip), %rsi # 0x59300a
callq 0x1a60c0
testl %eax, %eax
je 0x5353a0
movq %r13, %rdi
movq %r15, %rsi
callq 0x498b92
jmp 0x535376
movq 0x98(%r13), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x58(%rsp), %r13
jmp 0x53534f
movq 0x98(%r13), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x38(%rsp), %r13
movq 0x8(%r13), %rbx
movq %r12, %rdi
callq 0x1a56a0
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x1a5830
movq 0x90(%rsp), %r13
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x535392
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r14d
cmpl %r14d, %ebp
jne 0x535272
jmp 0x5353b2
movq %r13, %rdi
movl %r14d, %esi
leaq 0x78(%rsp), %rdx
callq 0x49b302
jmp 0x535376
cmpq $0x0, 0x40(%rsp)
je 0x53542e
movq %r13, %rdi
leaq 0x78(%rsp), %r12
callq 0x4997b6
cmpq $0x0, 0x60(%rsp)
je 0x5353d7
movq %r13, %rdi
callq 0x4989dc
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq %r13, %rdi
movl $0xc, %edx
callq 0x498494
testb %al, %al
jne 0x5353ff
leaq 0x38(%rsp), %rsi
movq %r13, %rdi
callq 0x4994f4
movq 0x90(%r13), %r13
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%r13), %rsi
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x48, %r13
jmp 0x5355a3
movl $0x78, %edi
leaq 0x78(%rsp), %r12
callq 0x1a5230
movq %rax, %r14
movq 0x90(%r13), %rax
movl $0xc, 0x8(%r14)
leaq 0x20(%r14), %rcx
movq %rcx, 0x10(%r14)
xorl %ecx, %ecx
movq %rcx, 0x18(%r14)
movb $0x0, 0x20(%r14)
movq %rax, 0x30(%r14)
leaq 0x38(%r14), %rax
movq %rax, 0x40(%r14)
movq %rax, 0x38(%r14)
movq %rcx, 0x48(%r14)
leaq 0x27638b(%rip), %rax # 0x7ab808
movq %rax, (%r14)
leaq 0x50(%r14), %r15
movq %r15, 0x58(%r14)
movq %r15, 0x50(%r14)
movq %rcx, 0x60(%r14)
movb $0x1, 0x70(%r14)
movq %r14, 0x10(%rsp)
cmpq %rcx, 0x60(%rsp)
je 0x5354b2
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x58(%rsp), %rsi
callq 0x1a64a0
movq 0x78(%rsp), %rbx
cmpq %r12, %rbx
je 0x5354fa
movsd 0x10(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
movl $0x20, %edi
callq 0x1a5230
movaps 0x90(%rsp), %xmm0
movlps %xmm0, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a5360
incq 0x60(%r14)
movq (%rbx), %rbx
jmp 0x5354b7
movq $0x1, 0x68(%r14)
movq 0x98(%r13), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x53553a
movq 0x90(%r13), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x535582
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9bbb1(%rip), %rsi # 0x5d10fb
leaq 0x9bbb5(%rip), %rdx # 0x5d1106
leaq 0x18(%rsp), %rdi
callq 0x209290
leaq 0x18(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x4a7412
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x535582
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x18, %edi
callq 0x1a5230
leaq 0x78(%r13), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x88, %r13
incq (%r13)
movq 0x78(%rsp), %rdi
cmpq %r12, %rdi
je 0x5355c6
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x1a5190
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0x5355b1
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x5355e2
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x5355fe
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
jne 0x535640
jmp 0x53564d
jmp 0x535629
jmp 0x535629
jmp 0x535629
jmp 0x535629
jmp 0x535629
movq %rax, %rbx
jmp 0x53564d
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x53564d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x78(%rsp), %rdi
leaq 0x78(%rsp), %r15
cmpq %r15, %rdi
je 0x535671
movq (%rdi), %r14
movl $0x18, %esi
callq 0x1a5190
movq %r14, %rdi
cmpq %r15, %r14
jne 0x53565c
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x53568d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x5356a9
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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_GetAttrVal_AsListVec2f);
MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_LOOPEND;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_TriangleSet2D, ne);
}
else
{
if(vertices.size() % 3) throw DeadlyImportError("TriangleSet2D. Not enough points for defining triangle.");
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_Geometry2D(CX3DImporter_NodeElement::ENET_TriangleSet2D, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
// convert vec2 to vec3
for(std::list<aiVector2D>::iterator it2 = vertices.begin(); it2 != vertices.end(); ++it2)
{
((CX3DImporter_NodeElement_Geometry2D*)ne)->Vertices.push_back(aiVector3D(it2->x, it2->y, 0));
}
((CX3DImporter_NodeElement_Geometry2D*)ne)->Solid = solid;
((CX3DImporter_NodeElement_Geometry2D*)ne)->NumIndices = 3;
// check for X3DMetadataObject childs.
if(!mReader->isEmptyElement())
ParseNode_Metadata(ne, "TriangleSet2D");
else
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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(%rcx)
movq %rcx, (%rcx)
movq %rax, 0x10(%rcx)
movq %rax, 0x30(%rsp)
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
xorl %r14d, %r14d
testl %eax, %eax
movq %rbx, (%rsp)
jle 0x535e08
leaq 0x10(%rsp), %r15
movq $0x0, 0x90(%rsp)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x23ca1c
movq %r15, %rdi
leaq 0x9c84b(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x535d56
movq %r15, %rdi
leaq 0x35560(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x535d70
movq %r15, %rdi
leaq 0x9ac5a(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x535dab
movq %r15, %rdi
leaq 0x9ac4e(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x535dab
movq %r15, %rdi
leaq 0x9ac40(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x535dab
movq %r15, %rdi
leaq 0x6cb4c(%rip), %rsi # 0x5a2871
callq 0x1a60c0
testl %eax, %eax
je 0x535dd5
movq %r15, %rdi
leaq 0x68aca(%rip), %rsi # 0x59e806
callq 0x1a60c0
testl %eax, %eax
je 0x535de7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x498b92
jmp 0x535dab
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x58(%rsp), %r13
jmp 0x535d88
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x38(%rsp), %r13
movq 0x8(%r13), %rbx
movq %r12, %rdi
callq 0x1a56a0
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x1a5830
movq (%rsp), %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x535dc7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r14d
cmpl %r14d, %ebp
jne 0x535c88
jmp 0x535dfc
movq %rbx, %rdi
movl %r14d, %esi
leaq 0x78(%rsp), %rdx
callq 0x49b302
jmp 0x535dab
movq %rbx, %rdi
movl %r14d, %esi
callq 0x499f12
movq %rax, 0x90(%rsp)
jmp 0x535dab
movq 0x90(%rsp), %r14
andb $0x1, %r14b
cmpq $0x0, 0x40(%rsp)
leaq 0x78(%rsp), %r13
je 0x535e93
movq %rbx, %rdi
callq 0x4997b6
cmpq $0x0, 0x60(%rsp)
je 0x535e2e
movq (%rsp), %rdi
callq 0x4989dc
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movq (%rsp), %rdi
movl $0xe, %edx
callq 0x498494
testb %al, %al
jne 0x535e58
leaq 0x38(%rsp), %rsi
movq (%rsp), %rdi
callq 0x4994f4
movq (%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, (%rsp)
movl $0x18, %edi
callq 0x1a5230
movq (%rsp), %rbx
leaq 0x38(%rbx), %rsi
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x48, %rbx
jmp 0x53603e
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq 0x88(%rsp), %rax
movabsq $0x5555555555555556, %rcx # imm = 0x5555555555555556
cmpq %rcx, %rax
jae 0x5360aa
movl $0x78, %edi
callq 0x1a5230
movq %rax, %r15
movq (%rsp), %rax
movq 0x90(%rax), %rax
movl $0xe, 0x8(%r15)
leaq 0x20(%r15), %rcx
movq %rcx, 0x10(%r15)
xorl %ecx, %ecx
movq %rcx, 0x18(%r15)
movb $0x0, 0x20(%r15)
movq %rax, 0x30(%r15)
leaq 0x38(%r15), %rax
movq %rax, 0x40(%r15)
movq %rax, 0x38(%r15)
movq %rcx, 0x48(%r15)
leaq 0x275901(%rip), %rax # 0x7ab808
movq %rax, (%r15)
leaq 0x50(%r15), %r12
movq %r12, 0x58(%r15)
movq %r12, 0x50(%r15)
movq %rcx, 0x60(%r15)
movb $0x1, 0x70(%r15)
movq %r15, 0x30(%rsp)
cmpq %rcx, 0x60(%rsp)
je 0x535f3c
movq %r15, %rdi
addq $0x10, %rdi
leaq 0x58(%rsp), %rsi
callq 0x1a64a0
movq 0x78(%rsp), %rbx
cmpq %r13, %rbx
je 0x535f84
movsd 0x10(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
movl $0x20, %edi
callq 0x1a5230
movaps 0x90(%rsp), %xmm0
movlps %xmm0, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5360
incq 0x60(%r15)
movq (%rbx), %rbx
jmp 0x535f41
movb %r14b, 0x70(%r15)
movq $0x3, 0x68(%r15)
movq (%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x535fd0
movq (%rsp), %rax
movq 0x90(%rax), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r15, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x536019
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x9b133(%rip), %rsi # 0x5d1113
leaq 0x9b139(%rip), %rdx # 0x5d1120
leaq 0x10(%rsp), %rdi
callq 0x209290
movq (%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
callq 0x4a7412
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x536019
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x18, %edi
callq 0x1a5230
movq (%rsp), %rbx
leaq 0x78(%rbx), %rsi
movq %r15, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x88, %rbx
incq (%rbx)
movq 0x78(%rsp), %rdi
cmpq %r13, %rdi
je 0x536060
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x1a5190
movq %rbx, %rdi
cmpq %r13, %rbx
jne 0x53604b
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x53607c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x536098
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa7558(%rip), %rsi # 0x5dd61f
leaq 0xa7588(%rip), %rdx # 0x5dd656
leaq 0x10(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x1a7649(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x1a7615(%rip), %rsi # 0x6dd710
movq 0x275e5e(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
jne 0x536168
jmp 0x536175
jmp 0x536151
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x536135
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x53613f
jmp 0x536175
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x536175
jmp 0x536151
jmp 0x536151
jmp 0x536151
jmp 0x536151
movq %rax, %rbx
jmp 0x536175
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x536175
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x78(%rsp), %rdi
leaq 0x78(%rsp), %r15
cmpq %r15, %rdi
je 0x536199
movq (%rdi), %r14
movl $0x18, %esi
callq 0x1a5190
movq %r14, %rdi
cmpq %r15, %r14
jne 0x536184
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x5361b5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x5361d1
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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, use);
MACRO_ATTRREAD_CHECK_RET("radius", radius, XML_ReadNode_GetAttrVal_AsFloat);
MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("bottom", bottom, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("top", top, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("side", side, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("height", height, XML_ReadNode_GetAttrVal_AsFloat);
MACRO_ATTRREAD_LOOPEND;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_Cylinder, ne);
}
else
{
const unsigned int tess = 30;///TODO: IME tessellation factor through ai_property
std::vector<aiVector3D> tside;// temp array for vertices of side.
std::vector<aiVector3D> tcir;// temp array for vertices of circle.
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_Geometry3D(CX3DImporter_NodeElement::ENET_Cylinder, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
// make cilynder or parts according to flags.
if(side) StandardShapes::MakeCone(height, radius, radius, tess, tside, true);
height /= 2;// height defined for whole cylinder, when creating top and bottom circle we are using just half of height.
if(top || bottom) StandardShapes::MakeCircle(radius, tess, tcir);
// copy data from temp arrays
std::list<aiVector3D>& vlist = ((CX3DImporter_NodeElement_Geometry3D*)ne)->Vertices;// just short alias.
for(std::vector<aiVector3D>::iterator it = tside.begin(); it != tside.end(); ++it) vlist.push_back(*it);
if(top)
{
for(std::vector<aiVector3D>::iterator it = tcir.begin(); it != tcir.end(); ++it)
{
(*it).y = height;// y - because circle made in oXZ.
vlist.push_back(*it);
}
}// if(top)
if(bottom)
{
for(std::vector<aiVector3D>::iterator it = tcir.begin(); it != tcir.end(); ++it)
{
(*it).y = -height;// y - because circle made in oXZ.
vlist.push_back(*it);
}
}// if(top)
((CX3DImporter_NodeElement_Geometry3D*)ne)->Solid = solid;
((CX3DImporter_NodeElement_Geometry3D*)ne)->NumIndices = 3;
// check for X3DMetadataObject childs.
if(!mReader->isEmptyElement())
ParseNode_Metadata(ne, "Cylinder");
else
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %r13d
testl %eax, %eax
jle 0x5371b5
movb $0x1, 0x9(%rsp)
xorl %r12d, %r12d
movss 0x24657(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0xc(%rsp)
movss 0x2469d(%rip), %xmm0 # 0x55b604
movaps %xmm0, 0x10(%rsp)
leaq 0x60(%rsp), %r15
movb $0x1, 0x8(%rsp)
movb $0x1, 0xb(%rsp)
movb $0x1, 0xa(%rsp)
movq %rbp, 0xc0(%rsp)
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r12d, %esi
callq *0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
leaq 0x40(%rsp), %rdx
callq 0x23ca1c
movq %r15, %rdi
leaq 0x9b54b(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x5370b2
movq %r15, %rdi
leaq 0x34260(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x5370cf
movq %r15, %rdi
leaq 0x9995a(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x537111
movq %r15, %rdi
leaq 0x9994e(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x537111
movq %r15, %rdi
leaq 0x99940(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x537111
movq %r15, %rdi
leaq 0x738ee(%rip), %rsi # 0x5aa913
callq 0x1a60c0
testl %eax, %eax
je 0x53713b
movq %r15, %rdi
leaq 0x677ca(%rip), %rsi # 0x59e806
callq 0x1a60c0
testl %eax, %eax
je 0x53714e
movq %r15, %rdi
leaq 0xa6398(%rip), %rsi # 0x5dd3eb
callq 0x1a60c0
testl %eax, %eax
je 0x53715f
movq %r15, %rdi
leaq 0x93120(%rip), %rsi # 0x5ca18a
callq 0x1a60c0
testl %eax, %eax
je 0x537170
movq %r15, %rdi
leaq 0x1768a(%rip), %rsi # 0x54e70b
callq 0x1a60c0
testl %eax, %eax
je 0x537181
movq %r15, %rdi
leaq 0x34d9b(%rip), %rsi # 0x56be33
callq 0x1a60c0
testl %eax, %eax
je 0x537195
movq %rbp, %rdi
movq %r15, %rsi
callq 0x498b92
jmp 0x537111
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r12d, %esi
callq *0x30(%rax)
movq %rax, %r14
leaq 0x80(%rsp), %rbp
jmp 0x5370ea
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r12d, %esi
callq *0x30(%rax)
movq %rax, %r14
leaq 0xa0(%rsp), %rbp
movq 0x8(%rbp), %rbx
movq %r14, %rdi
callq 0x1a56a0
movq %rbp, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x1a5830
movq 0xc0(%rsp), %rbp
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x53712d
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r12d
cmpl %r12d, %r13d
jne 0x536f88
jmp 0x5371aa
movq %rbp, %rdi
movl %r12d, %esi
callq 0x49a228
movss %xmm0, 0xc(%rsp)
jmp 0x537111
movq %rbp, %rdi
movl %r12d, %esi
callq 0x499f12
movb %al, 0xb(%rsp)
jmp 0x537111
movq %rbp, %rdi
movl %r12d, %esi
callq 0x499f12
movb %al, 0x9(%rsp)
jmp 0x537111
movq %rbp, %rdi
movl %r12d, %esi
callq 0x499f12
movb %al, 0x8(%rsp)
jmp 0x537111
movq %rbp, %rdi
movl %r12d, %esi
callq 0x499f12
movb %al, 0xa(%rsp)
jmp 0x537111
movq %rbp, %rdi
movl %r12d, %esi
callq 0x49a228
movaps %xmm0, 0x10(%rsp)
jmp 0x537111
movb 0xb(%rsp), %r13b
andb $0x1, %r13b
jmp 0x5371e2
movss 0x24447(%rip), %xmm0 # 0x55b604
movaps %xmm0, 0x10(%rsp)
movss 0x243e6(%rip), %xmm0 # 0x55b5b0
movss %xmm0, 0xc(%rsp)
movb $0x1, 0xa(%rsp)
movb $0x1, %r13b
movb $0x1, 0x8(%rsp)
movb $0x1, 0x9(%rsp)
cmpq $0x0, 0xa8(%rsp)
je 0x537265
movq %rbp, %rdi
callq 0x4997b6
cmpq $0x0, 0x88(%rsp)
je 0x537208
movq %rbp, %rdi
callq 0x4989dc
leaq 0xa0(%rsp), %rsi
leaq 0x38(%rsp), %rcx
movq %rbp, %rdi
movl $0x11, %edx
callq 0x498494
testb %al, %al
jne 0x537236
leaq 0xa0(%rsp), %rsi
movq %rbp, %rdi
callq 0x4994f4
movq 0x90(%rbp), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x53751f
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
xorl %eax, %eax
movq %rax, 0x50(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x78, %edi
callq 0x1a5230
movq %rax, %r15
movq %rax, %r14
movq 0x90(%rbp), %rax
movl $0x11, 0x8(%r15)
leaq 0x20(%r15), %rcx
movq %rcx, 0x10(%r15)
xorl %ecx, %ecx
movq %rcx, 0x18(%r15)
movb $0x0, 0x20(%r15)
movq %rax, 0x30(%r15)
leaq 0x38(%r15), %rax
movq %rax, 0x40(%r15)
movq %rax, 0x38(%r15)
movq %rcx, 0x48(%r15)
leaq 0x274575(%rip), %rax # 0x7ab840
movq %rax, (%r15)
leaq 0x50(%r15), %r12
movq %r12, 0x58(%r15)
movq %r12, 0x50(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r15)
movb $0x1, 0x70(%r15)
movq %r15, 0x38(%rsp)
cmpq %rcx, 0x88(%rsp)
je 0x537307
leaq 0x10(%r15), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1a64a0
testb $0x1, 0xa(%rsp)
je 0x537330
leaq 0x40(%rsp), %rsi
movaps 0x10(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
movaps %xmm1, %xmm2
movl $0x1e, %edi
movl $0x1, %edx
callq 0x521fce
movb 0x8(%rsp), %al
orb 0x9(%rsp), %al
testb $0x1, %al
je 0x537351
leaq 0x20(%rsp), %rsi
movss 0xc(%rsp), %xmm0
movl $0x1e, %edi
callq 0x522690
addq $0x60, %r15
movq 0x40(%rsp), %rbx
cmpq 0x48(%rsp), %rbx
je 0x53738c
movl $0x20, %edi
callq 0x1a5230
movl 0x8(%rbx), %ecx
movl %ecx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5360
incq (%r15)
addq $0xc, %rbx
jmp 0x53735a
movaps 0x10(%rsp), %xmm0
mulss 0x24223(%rip), %xmm0 # 0x55b5bc
movaps %xmm0, 0x10(%rsp)
testb $0x1, 0x8(%rsp)
je 0x5373e6
movq 0x20(%rsp), %rbx
cmpq 0x28(%rsp), %rbx
je 0x5373e6
movaps 0x10(%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
movl $0x20, %edi
callq 0x1a5230
movl 0x8(%rbx), %ecx
movl %ecx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5360
incq (%r15)
addq $0xc, %rbx
jmp 0x5373aa
testb $0x1, 0x9(%rsp)
je 0x537444
movq 0x20(%rsp), %rbx
cmpq 0x28(%rsp), %rbx
je 0x537444
movaps 0x10(%rsp), %xmm0
xorps 0x23e9b(%rip), %xmm0 # 0x55b2a0
movaps %xmm0, 0x10(%rsp)
movaps 0x10(%rsp), %xmm0
movss %xmm0, 0x4(%rbx)
movl $0x20, %edi
callq 0x1a5230
movl 0x8(%rbx), %ecx
movl %ecx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a5360
incq (%r15)
addq $0xc, %rbx
cmpq 0x28(%rsp), %rbx
jne 0x53740a
movb %r13b, 0x70(%r14)
movq $0x3, 0x68(%r14)
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x537488
movq 0x90(%rbp), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x5374d0
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7f189(%rip), %rsi # 0x5b6621
leaq 0x7f18a(%rip), %rdx # 0x5b6629
leaq 0x60(%rsp), %rdi
callq 0x209290
leaq 0x60(%rsp), %rdx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4a7412
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x5374d0
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x18, %edi
callq 0x1a5230
leaq 0x78(%rbp), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x88(%rbp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x537508
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x53751f
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x537544
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x537569
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x5375a8
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x5375a8
jmp 0x5375a5
jmp 0x5375a5
jmp 0x5375a5
jmp 0x5375d5
jmp 0x5375d5
jmp 0x5375a5
jmp 0x5375a5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5375bf
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x5375f9
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
jmp 0x5375f4
jmp 0x5375d5
movq %rax, %rbx
jmp 0x5375f9
movq %rax, %rbx
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x5375f9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x53761e
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x537643
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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 normalPerVertex = true;
bool solid = true;
std::vector<int32_t> texCoordIndex;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_REF("colorIndex", colorIndex, XML_ReadNode_GetAttrVal_AsArrI32);
MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("convex", convex, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_REF("coordIndex", coordIndex, XML_ReadNode_GetAttrVal_AsArrI32);
MACRO_ATTRREAD_CHECK_RET("creaseAngle", creaseAngle, XML_ReadNode_GetAttrVal_AsFloat);
MACRO_ATTRREAD_CHECK_REF("normalIndex", normalIndex, XML_ReadNode_GetAttrVal_AsArrI32);
MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_REF("texCoordIndex", texCoordIndex, XML_ReadNode_GetAttrVal_AsArrI32);
MACRO_ATTRREAD_LOOPEND;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_IndexedFaceSet, ne);
}
else
{
// check data
if(coordIndex.size() == 0) throw DeadlyImportError("IndexedFaceSet must contain not empty \"coordIndex\" attribute.");
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_IndexedFaceSet, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
CX3DImporter_NodeElement_IndexedSet& ne_alias = *((CX3DImporter_NodeElement_IndexedSet*)ne);
ne_alias.CCW = ccw;
ne_alias.ColorIndex = colorIndex;
ne_alias.ColorPerVertex = colorPerVertex;
ne_alias.Convex = convex;
ne_alias.CoordIndex = coordIndex;
ne_alias.CreaseAngle = creaseAngle;
ne_alias.NormalIndex = normalIndex;
ne_alias.NormalPerVertex = normalPerVertex;
ne_alias.Solid = solid;
ne_alias.TexCoordIndex = texCoordIndex;
// check for child nodes
if(!mReader->isEmptyElement())
{
ParseHelper_Node_Enter(ne);
MACRO_NODECHECK_LOOPBEGIN("IndexedFaceSet");
// check for X3DComposedGeometryNodes
if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
// check for X3DMetadataObject
if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("IndexedFaceSet");
MACRO_NODECHECK_LOOPEND("IndexedFaceSet");
ParseHelper_Node_Exit();
}// if(!mReader->isEmptyElement())
else
{
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
}
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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, %xmm0
movaps %xmm0, 0xe0(%rsp)
movq %rax, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rax, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movq %rax, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movq %rax, 0x28(%rsp)
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
xorps %xmm0, %xmm0
testl %eax, %eax
jle 0x53a53d
movss %xmm0, 0x34(%rsp)
xorl %r14d, %r14d
movb $0x1, 0x7(%rsp)
leaq 0x8(%rsp), %r12
movb $0x1, 0x6(%rsp)
movb $0x1, 0x3(%rsp)
movb $0x1, 0x4(%rsp)
movb $0x1, 0x5(%rsp)
movl %ebp, 0x3c(%rsp)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x28(%rax)
movq %r12, %rdi
movq %rax, %rsi
leaq 0x3b(%rsp), %rdx
callq 0x23ca1c
movq %r12, %rdi
leaq 0x9825e(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x53a418
movq %r12, %rdi
leaq 0x30f73(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x53a432
movq %r12, %rdi
leaq 0x9666d(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x53a470
movq %r12, %rdi
leaq 0x96661(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x53a470
movq %r12, %rdi
leaq 0x96653(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x53a470
movq %r12, %rdi
leaq 0x97cf0(%rip), %rsi # 0x5d2002
callq 0x1a60c0
testl %eax, %eax
je 0x53a49a
movq %r12, %rdi
leaq 0x97c96(%rip), %rsi # 0x5d1fbf
callq 0x1a60c0
leaq 0xe0(%rsp), %rdx
testl %eax, %eax
je 0x53a4ab
movq %r12, %rdi
leaq 0x97c9b(%rip), %rsi # 0x5d1fe3
callq 0x1a60c0
testl %eax, %eax
je 0x53a4b8
movq %r12, %rdi
leaq 0x8c8e2(%rip), %rsi # 0x5c6c41
callq 0x1a60c0
testl %eax, %eax
je 0x53a4c9
movq %r12, %rdi
leaq 0x97c54(%rip), %rsi # 0x5d1fca
callq 0x1a60c0
leaq 0x40(%rsp), %rdx
testl %eax, %eax
je 0x53a4ab
movq %r12, %rdi
leaq 0x97ec5(%rip), %rsi # 0x5d2257
callq 0x1a60c0
testl %eax, %eax
je 0x53a4da
movq %r12, %rdi
leaq 0x91161(%rip), %rsi # 0x5cb50a
callq 0x1a60c0
leaq 0xc0(%rsp), %rdx
testl %eax, %eax
je 0x53a4ab
movq %r12, %rdi
leaq 0x97c2a(%rip), %rsi # 0x5d1ff2
callq 0x1a60c0
testl %eax, %eax
je 0x53a4ed
movq %r12, %rdi
leaq 0x64427(%rip), %rsi # 0x59e806
callq 0x1a60c0
testl %eax, %eax
je 0x53a501
movq %r12, %rdi
leaq 0x97bdf(%rip), %rsi # 0x5d1fd5
callq 0x1a60c0
leaq 0xa0(%rsp), %rdx
testl %eax, %eax
je 0x53a4ab
movq %rbx, %rdi
movq %r12, %rsi
callq 0x498b92
jmp 0x53a470
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x60(%rsp), %r15
jmp 0x53a44d
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x80(%rsp), %r15
movq 0x8(%r15), %rbp
movq %r13, %rdi
callq 0x1a56a0
movq %r15, %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x1a5830
movl 0x3c(%rsp), %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x53a48c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r14d
cmpl %r14d, %ebp
jne 0x53a275
jmp 0x53a515
movq %rbx, %rdi
movl %r14d, %esi
callq 0x499f12
movb %al, 0x7(%rsp)
jmp 0x53a470
movq %rbx, %rdi
movl %r14d, %esi
callq 0x49ac40
jmp 0x53a470
movq %rbx, %rdi
movl %r14d, %esi
callq 0x499f12
movb %al, 0x6(%rsp)
jmp 0x53a470
movq %rbx, %rdi
movl %r14d, %esi
callq 0x499f12
movb %al, 0x5(%rsp)
jmp 0x53a470
movq %rbx, %rdi
movl %r14d, %esi
callq 0x49a228
movss %xmm0, 0x34(%rsp)
jmp 0x53a470
movq %rbx, %rdi
movl %r14d, %esi
callq 0x499f12
movb %al, 0x4(%rsp)
jmp 0x53a470
movq %rbx, %rdi
movl %r14d, %esi
callq 0x499f12
movb %al, 0x3(%rsp)
jmp 0x53a470
andb $0x1, 0x7(%rsp)
andb $0x1, 0x6(%rsp)
andb $0x1, 0x5(%rsp)
andb $0x1, 0x4(%rsp)
andb $0x1, 0x3(%rsp)
leaq 0x90(%rsp), %r15
leaq 0x70(%rsp), %r12
jmp 0x53a55c
movss %xmm0, 0x34(%rsp)
movb $0x1, 0x5(%rsp)
movb $0x1, 0x4(%rsp)
movb $0x1, 0x3(%rsp)
movb $0x1, 0x6(%rsp)
movb $0x1, 0x7(%rsp)
cmpq $0x0, 0x88(%rsp)
je 0x53a5dc
movq %rbx, %rdi
callq 0x4997b6
cmpq $0x0, 0x68(%rsp)
je 0x53a57f
movq %rbx, %rdi
callq 0x4989dc
leaq 0x80(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
movl $0x18, %edx
callq 0x498494
testb %al, %al
jne 0x53a5ad
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x4994f4
movq 0x90(%rbx), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x48, %rbx
jmp 0x53aaf2
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x53aba9
movl $0xf0, %edi
callq 0x1a5230
movq %rax, %r14
movq 0x90(%rbx), %rax
movl $0x18, 0x8(%r14)
leaq 0x20(%r14), %rcx
movq %rcx, 0x10(%r14)
xorl %ecx, %ecx
movq %rcx, 0x18(%r14)
movb $0x0, 0x20(%r14)
movq %rax, 0x30(%r14)
leaq 0x38(%r14), %rax
movq %rax, 0x40(%r14)
movq %rax, 0x38(%r14)
movq %rcx, 0x48(%r14)
leaq 0x50(%r14), %rax
movq %rax, 0x58(%r14)
movq %rax, 0x50(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movb $0x1, 0x70(%r14)
leaq 0x271261(%rip), %rax # 0x7ab8b0
movq %rax, (%r14)
movups %xmm0, 0x78(%r14)
movq %rcx, 0x88(%r14)
movups %xmm0, 0x98(%r14)
movq %rcx, 0xa8(%r14)
movups %xmm0, 0xb8(%r14)
movq %rcx, 0xc8(%r14)
movq %rcx, 0xe8(%r14)
movups %xmm0, 0xd8(%r14)
movq %r14, 0x28(%rsp)
cmpq %rcx, 0x68(%rsp)
je 0x53a6ad
addq $0x10, %r14
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x1a64a0
movq 0x28(%rsp), %r14
movb 0x7(%rsp), %al
movb %al, 0x71(%r14)
leaq 0x78(%r14), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x4a0978
movb 0x6(%rsp), %al
movb %al, 0x90(%r14)
movb 0x5(%rsp), %al
movb %al, 0x91(%r14)
leaq 0x98(%r14), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4a0978
movss 0x34(%rsp), %xmm0
movss %xmm0, 0xb0(%r14)
leaq 0xb8(%r14), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x4a0978
movb 0x4(%rsp), %al
movb %al, 0xd0(%r14)
movb 0x3(%rsp), %al
movb %al, 0x70(%r14)
addq $0xd8, %r14
leaq 0xa0(%rsp), %rsi
movq %r14, %rdi
callq 0x4a0978
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x53a77a
movq 0x90(%rbx), %r14
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%r14), %rsi
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%r14)
jmp 0x53aacc
movq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x49ed82
leaq 0x18(%rsp), %rbp
leaq 0xed9d(%rip), %r14 # 0x549530
leaq 0xed9b(%rip), %r15 # 0x549535
leaq 0x8(%rsp), %r12
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x53aa78
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x53a9c6
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x209290
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %r13d
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53a80f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %r13d, %r13d
je 0x53aa37
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
leaq 0x97737(%rip), %rsi # 0x5d1f5e
leaq 0x97739(%rip), %rdx # 0x5d1f67
callq 0x209290
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %r13d
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53a865
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %r13d, %r13d
je 0x53aa44
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
leaq 0x986f4(%rip), %rsi # 0x5d2f71
leaq 0x986f7(%rip), %rdx # 0x5d2f7b
callq 0x209290
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %r13d
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53a8bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %r13d, %r13d
je 0x53aa51
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
leaq 0x9867e(%rip), %rsi # 0x5d2f51
leaq 0x9867d(%rip), %rdx # 0x5d2f57
callq 0x209290
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %r13d
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53a911
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %r13d, %r13d
je 0x53aa5e
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
leaq 0x98641(%rip), %rsi # 0x5d2f6a
leaq 0x9864b(%rip), %rdx # 0x5d2f7b
callq 0x209290
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %r13d
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53a967
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %r13d, %r13d
je 0x53aa6b
movq %rbx, %rdi
callq 0x4a4f84
testb %al, %al
jne 0x53a79f
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
leaq 0x96792(%rip), %rsi # 0x5d1121
leaq 0x96799(%rip), %rdx # 0x5d112f
callq 0x209290
movq %rbx, %rdi
movq %r12, %rsi
callq 0x499986
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53a79f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x53a79f
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, %eax
jne 0x53a79f
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
leaq 0x96736(%rip), %rsi # 0x5d1121
leaq 0x9673d(%rip), %rdx # 0x5d112f
callq 0x209290
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %r13d
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53aa29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %r13d, %r13d
jne 0x53a79f
jmp 0x53aab7
movq %rbx, %rdi
callq 0x53b6f8
jmp 0x53a79f
movq %rbx, %rdi
callq 0x53bb64
jmp 0x53a79f
movq %rbx, %rdi
callq 0x53bfd0
jmp 0x53a79f
movq %rbx, %rdi
callq 0x53d810
jmp 0x53a79f
movq %rbx, %rdi
callq 0x4ad5ae
jmp 0x53a79f
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x9669a(%rip), %rsi # 0x5d1121
leaq 0x966a1(%rip), %rdx # 0x5d112f
callq 0x209290
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4985f4
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53aab7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
leaq 0x90(%rsp), %r15
leaq 0x70(%rsp), %r12
callq 0x49edce
movl $0x18, %edi
callq 0x1a5230
leaq 0x78(%rbx), %rsi
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x88, %rbx
incq (%rbx)
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x53ab12
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x53ab2f
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x53ab46
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x53ab63
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x53ab7a
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x53ab97
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa2c27(%rip), %rsi # 0x5dd7ed
leaq 0xa2c5d(%rip), %rdx # 0x5dd82a
leaq 0x8(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x1a2b4a(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x1a2b16(%rip), %rsi # 0x6dd710
movq 0x27135f(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x53ac55
jmp 0x53ac71
jmp 0x53ac55
jmp 0x53ac71
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x53ac2b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x53ac35
jmp 0x53ac74
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a6080
jmp 0x53ac74
jmp 0x53ac71
jmp 0x53ac55
jmp 0x53ac55
jmp 0x53ac71
jmp 0x53ac71
jmp 0x53ac55
jmp 0x53ac71
jmp 0x53ac71
jmp 0x53ac55
jmp 0x53ac71
jmp 0x53ac55
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53ac74
jmp 0x53ad41
jmp 0x53ac71
jmp 0x53ac71
jmp 0x53ac71
jmp 0x53ac71
jmp 0x53ac71
movq %rax, %rbx
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x53ac91
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x53acae
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x53acc5
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x53ace2
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x53acfe
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x53ad23
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x53ac74
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x53ac74
nop
| /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 "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_Normal, ne);
}
else
{
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_Normal(NodeElement_Cur);
if(!def.empty()) ne->ID = def;
((CX3DImporter_NodeElement_Normal*)ne)->Value = vector;
// check for X3DMetadataObject childs.
if(!mReader->isEmptyElement())
ParseNode_Metadata(ne, "Normal");
else
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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(%rcx)
movq %rcx, (%rcx)
movq %rax, 0x10(%rcx)
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
testl %eax, %eax
jle 0x53d9c2
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r12, 0x88(%rsp)
movq 0x98(%r12), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x28(%rax)
movq %r15, %rdi
movq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x23ca1c
movq %r15, %rdi
leaq 0x94c57(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x53d92b
movq %r15, %rdi
leaq 0x2d970(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x53d946
movq %r15, %rdi
leaq 0x9306a(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x53d986
movq %r15, %rdi
leaq 0x9305e(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x53d986
movq %r15, %rdi
leaq 0x93050(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x53d986
movq %r15, %rdi
leaq 0x56d43(%rip), %rsi # 0x594654
callq 0x1a60c0
testl %eax, %eax
je 0x53d9b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x498b92
jmp 0x53d986
movq 0x98(%r12), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x30(%rsp), %r13
jmp 0x53d95f
movq 0x98(%r12), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x30(%rax)
movq %rax, %r12
leaq 0x50(%rsp), %r13
movq 0x8(%r13), %rbx
movq %r12, %rdi
callq 0x1a56a0
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x1a5830
movq 0x88(%rsp), %r12
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x53d9a2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r14d
cmpl %r14d, %ebp
jne 0x53d87b
jmp 0x53d9c2
movq %r12, %rdi
movl %r14d, %esi
leaq 0x70(%rsp), %rdx
callq 0x49b4e4
jmp 0x53d986
cmpq $0x0, 0x58(%rsp)
je 0x53da41
movq %r12, %rdi
callq 0x4997b6
cmpq $0x0, 0x38(%rsp)
je 0x53d9e2
movq %r12, %rdi
callq 0x4989dc
leaq 0x50(%rsp), %rsi
leaq 0x90(%rsp), %rcx
movq %r12, %rdi
movl $0x16, %edx
callq 0x498494
testb %al, %al
jne 0x53da0d
leaq 0x50(%rsp), %rsi
movq %r12, %rdi
callq 0x4994f4
movq 0x90(%r12), %r12
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%r12), %rsi
movq 0x90(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x48, %r12
jmp 0x53db6b
movl $0x68, %edi
callq 0x1a5230
movq %rax, %r14
movq 0x90(%r12), %rax
movl $0x16, 0x8(%r14)
leaq 0x20(%r14), %rcx
movq %rcx, 0x10(%r14)
xorl %ecx, %ecx
movq %rcx, 0x18(%r14)
movb $0x0, 0x20(%r14)
movq %rax, 0x30(%r14)
leaq 0x38(%r14), %rax
movq %rax, 0x40(%r14)
movq %rax, 0x38(%r14)
movq %rcx, 0x48(%r14)
leaq 0x26df3c(%rip), %rax # 0x7ab9c8
movq %rax, (%r14)
leaq 0x50(%r14), %r15
movq %r15, 0x58(%r14)
movq %r15, 0x50(%r14)
movq %rcx, 0x60(%r14)
cmpq %rcx, 0x38(%rsp)
je 0x53dab7
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x30(%rsp), %rsi
callq 0x1a64a0
leaq 0x70(%rsp), %rdx
movq (%rdx), %rsi
movq %r15, %rdi
callq 0x53626a
movq 0x98(%r12), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x53db01
movq 0x90(%r12), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x53db49
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x95440(%rip), %rsi # 0x5d2f51
leaq 0x9543f(%rip), %rdx # 0x5d2f57
leaq 0x10(%rsp), %rdi
callq 0x209290
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x4a7412
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x53db49
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movl $0x18, %edi
callq 0x1a5230
leaq 0x78(%r12), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x88, %r12
incq (%r12)
movq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %r14
cmpq %r14, %rdi
je 0x53db93
movq (%rdi), %rbx
movl $0x20, %esi
callq 0x1a5190
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x53db7e
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x53dbaf
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x53dbcb
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
jne 0x53dc0b
jmp 0x53dc18
jmp 0x53dbf4
jmp 0x53dbf4
jmp 0x53dbf4
jmp 0x53dbf4
movq %rax, %rbx
jmp 0x53dc18
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x53dc18
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %r15
cmpq %r15, %rdi
je 0x53dc3c
movq (%rdi), %r14
movl $0x20, %esi
callq 0x1a5190
movq %r14, %rdi
cmpq %r15, %r14
jne 0x53dc27
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x53dc58
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x53dc74
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbx, %rdi
callq 0x1a5b90
| /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_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_REF("fanCount", fanCount, XML_ReadNode_GetAttrVal_AsArrI32);
MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_LOOPEND;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_TriangleFanSet, ne);
}
else
{
// check data
if(fanCount.size() == 0) throw DeadlyImportError("TriangleFanSet must contain not empty \"fanCount\" attribute.");
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_Set(CX3DImporter_NodeElement::ENET_TriangleFanSet, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
CX3DImporter_NodeElement_Set& ne_alias = *((CX3DImporter_NodeElement_Set*)ne);
ne_alias.CCW = ccw;
ne_alias.ColorPerVertex = colorPerVertex;
ne_alias.VertexCount = fanCount;
ne_alias.NormalPerVertex = normalPerVertex;
ne_alias.Solid = solid;
// create CoordIdx
size_t coord_num_first, coord_num_prev;
ne_alias.CoordIndex.clear();
// assign indices for first triangle
coord_num_first = 0;
coord_num_prev = 1;
for(std::vector<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); ++vc_it)
{
if(*vc_it < 3) throw DeadlyImportError("TriangleFanSet. fanCount shall be greater than or equal to three.");
for(int32_t vc = 2; vc < *vc_it; vc++)
{
if(ccw)
{
// 2 1
// 0
ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_first));// first vertex is a center and always is [0].
ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev++));
ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev));
}
else
{
// 1 2
// 0
ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_first));// first vertex is a center and always is [0].
ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev + 1));
ne_alias.CoordIndex.push_back(static_cast<int32_t>(coord_num_prev++));
}// if(ccw) else
ne_alias.CoordIndex.push_back(-1);// add face delimiter.
}// for(int32_t vc = 2; vc < *vc_it; vc++)
coord_num_prev++;// that index will be center of next fan
coord_num_first = coord_num_prev++;// forward to next point - second point of fan
}// for(std::list<int32_t>::const_iterator vc_it = ne_alias.VertexCount.begin(); vc_it != ne_alias.VertexCount.end(); vc_it++)
// check for child nodes
if(!mReader->isEmptyElement())
{
ParseHelper_Node_Enter(ne);
MACRO_NODECHECK_LOOPBEGIN("TriangleFanSet");
// check for X3DComposedGeometryNodes
if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
// check for X3DMetadataObject
if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("TriangleFanSet");
MACRO_NODECHECK_LOOPEND("TriangleFanSet");
ParseHelper_Node_Exit();
}// if(!mReader->isEmptyElement())
else
{
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
}
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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, %xmm0
movaps %xmm0, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebx
testl %eax, %eax
jle 0x540447
xorl %r15d, %r15d
movb $0x1, 0xf(%rsp)
leaq 0x10(%rsp), %r12
movb $0x1, 0x50(%rsp)
movb $0x1, 0x30(%rsp)
movb $0x1, 0x38(%rsp)
movl %ebx, 0x48(%rsp)
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x28(%rax)
movq %r12, %rdi
movq %rax, %rsi
leaq 0x47(%rsp), %rdx
callq 0x23ca1c
movq %r12, %rdi
leaq 0x92292(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x540354
movq %r12, %rdi
leaq 0x2afa7(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x54036e
movq %r12, %rdi
leaq 0x906a1(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x5403ac
movq %r12, %rdi
leaq 0x90695(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x5403ac
movq %r12, %rdi
leaq 0x90687(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x5403ac
movq %r12, %rdi
leaq 0x91d24(%rip), %rsi # 0x5d2002
callq 0x1a60c0
testl %eax, %eax
je 0x5403d6
movq %r12, %rdi
leaq 0x91cee(%rip), %rsi # 0x5d1fe3
callq 0x1a60c0
testl %eax, %eax
je 0x5403e7
movq %r12, %rdi
leaq 0x920d8(%rip), %rsi # 0x5d23e4
callq 0x1a60c0
testl %eax, %eax
je 0x5403f8
movq %r12, %rdi
leaq 0x91ccf(%rip), %rsi # 0x5d1ff2
callq 0x1a60c0
testl %eax, %eax
je 0x54040a
movq %r12, %rdi
leaq 0x5e4cc(%rip), %rsi # 0x59e806
callq 0x1a60c0
testl %eax, %eax
je 0x54041b
movq %rbp, %rdi
movq %r12, %rsi
callq 0x498b92
jmp 0x5403ac
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x78(%rsp), %rbx
jmp 0x540389
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x98(%rsp), %rbx
movq 0x8(%rbx), %r14
movq %r13, %rdi
callq 0x1a56a0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x1a5830
movl 0x48(%rsp), %ebx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x5403c8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r15d
cmpl %r15d, %ebx
jne 0x540241
jmp 0x54042c
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0xf(%rsp)
jmp 0x5403ac
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0x50(%rsp)
jmp 0x5403ac
movq %rbp, %rdi
movl %r15d, %esi
leaq 0x60(%rsp), %rdx
callq 0x49ac40
jmp 0x5403ac
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0x38(%rsp)
jmp 0x5403ac
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0x30(%rsp)
jmp 0x5403ac
movb 0x50(%rsp), %r12b
andb $0x1, %r12b
movb 0x38(%rsp), %r15b
andb $0x1, %r15b
movb 0x30(%rsp), %bl
andb $0x1, %bl
jmp 0x540454
movb $0x1, %r15b
movb $0x1, %bl
movb $0x1, %r12b
movb $0x1, 0xf(%rsp)
cmpq $0x0, 0xa0(%rsp)
je 0x5404d7
movq %rbp, %rdi
callq 0x4997b6
cmpq $0x0, 0x80(%rsp)
je 0x54047a
movq %rbp, %rdi
callq 0x4989dc
leaq 0x98(%rsp), %rsi
leaq 0x58(%rsp), %rcx
movq %rbp, %rdi
movl $0x20, %edx
callq 0x498494
testb %al, %al
jne 0x5404a8
leaq 0x98(%rsp), %rsi
movq %rbp, %rdi
callq 0x4994f4
movq 0x90(%rbp), %rbp
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbp), %rsi
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x48, %rbp
jmp 0x540acb
movq 0x68(%rsp), %rax
cmpq 0x60(%rsp), %rax
je 0x540ba1
movl $0xd8, %edi
callq 0x1a5230
movq %rax, %r13
movq 0x90(%rbp), %rax
movl $0x20, 0x8(%r13)
leaq 0x20(%r13), %rcx
movq %rcx, 0x10(%r13)
xorl %ecx, %ecx
movq %rcx, 0x18(%r13)
movb $0x0, 0x20(%r13)
movq %rax, 0x30(%r13)
leaq 0x38(%r13), %rax
movq %rax, 0x40(%r13)
movq %rax, 0x38(%r13)
movq %rcx, 0x48(%r13)
leaq 0x50(%r13), %rax
movq %rax, 0x58(%r13)
movq %rax, 0x50(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r13)
movb $0x1, 0x70(%r13)
leaq 0x26b446(%rip), %rax # 0x7ab990
movq %rax, (%r13)
movups %xmm0, 0x78(%r13)
movups %xmm0, 0x88(%r13)
movups %xmm0, 0x98(%r13)
movups %xmm0, 0xa8(%r13)
movups %xmm0, 0xb8(%r13)
movups %xmm0, 0xc8(%r13)
movq %r13, 0x58(%rsp)
cmpq %rcx, 0x80(%rsp)
je 0x540598
leaq 0x10(%r13), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1a64a0
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x71(%r13)
movb %r12b, 0x72(%r13)
leaq 0xc0(%r13), %rdi
leaq 0x60(%rsp), %rsi
callq 0x4a0978
movq %rbp, 0x30(%rsp)
movb %r15b, 0x73(%r13)
movb %bl, 0x70(%r13)
movq 0x78(%r13), %rax
cmpq %rax, 0x80(%r13)
je 0x5405d8
movq %rax, 0x80(%r13)
movq 0xc0(%r13), %r14
movq %r13, 0x38(%rsp)
cmpq 0xc8(%r13), %r14
je 0x5406ef
movq 0x38(%rsp), %r15
addq $0x78, %r15
movl $0x1, %r13d
movq $0x0, 0x48(%rsp)
leaq 0x10(%rsp), %r12
cmpl $0x3, (%r14)
jl 0x540b3f
movl $0x2, %ebp
movq %r14, 0x50(%rsp)
testb $0x1, 0xf(%rsp)
je 0x540662
movq 0x48(%rsp), %rax
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4a13bc
movl %r13d, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4a13bc
incq %r13
movl %r13d, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4a13bc
jmp 0x5406ae
movq 0x48(%rsp), %rax
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4a13bc
leaq 0x1(%r13), %r14
movl %r14d, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4a13bc
movl %r13d, 0x10(%rsp)
movq %r15, %rbx
movq %r15, %rdi
movq %r12, %r15
movq %r12, %rsi
callq 0x4a13bc
movq %r14, %r13
movq 0x50(%rsp), %r14
movq %r15, %r12
movq %rbx, %r15
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r12, %rsi
callq 0x4a13bc
incl %ebp
cmpl (%r14), %ebp
jl 0x540622
leaq 0x1(%r13), %rax
movq %rax, 0x48(%rsp)
addq $0x2, %r13
addq $0x4, %r14
movq 0x38(%rsp), %rax
cmpq 0xc8(%rax), %r14
jne 0x54060e
movq 0x30(%rsp), %rbp
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movq 0x38(%rsp), %r14
testb %al, %al
je 0x540734
movq 0x90(%rbp), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x540aaa
movq %rbp, %rdi
movq %r14, %rsi
callq 0x49ed82
leaq 0x20(%rsp), %rbx
leaq 0x8de5(%rip), %r15 # 0x549530
leaq 0x8de3(%rip), %r12 # 0x549535
leaq 0x10(%rsp), %r13
leaq 0x91800(%rip), %r14 # 0x5d1f5e
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x540a5e
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x540990
movq %rbx, 0x10(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x209290
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5407cd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x540a04
movq %rbx, 0x10(%rsp)
movq %r13, %rdi
movq %r14, %rsi
leaq 0x91780(%rip), %rdx # 0x5d1f67
callq 0x209290
movq 0x30(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x540822
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x540a16
movq %rbx, 0x10(%rsp)
movq %r13, %rdi
leaq 0x92738(%rip), %rsi # 0x5d2f71
leaq 0x9273b(%rip), %rdx # 0x5d2f7b
callq 0x209290
movq 0x30(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x54087b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x540a28
movq %rbx, 0x10(%rsp)
movq %r13, %rdi
leaq 0x926bf(%rip), %rsi # 0x5d2f51
leaq 0x926be(%rip), %rdx # 0x5d2f57
callq 0x209290
movq 0x30(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5408d4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x540a3a
movq %rbx, 0x10(%rsp)
movq %r13, %rdi
leaq 0x9267f(%rip), %rsi # 0x5d2f6a
leaq 0x92689(%rip), %rdx # 0x5d2f7b
callq 0x209290
movq 0x30(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x54092d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x540a4c
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x4a4f84
testb %al, %al
jne 0x54075e
movq %rbx, 0x10(%rsp)
movq %r13, %rdi
leaq 0x907f6(%rip), %rsi # 0x5d114f
leaq 0x907fd(%rip), %rdx # 0x5d115d
callq 0x209290
movq %rbp, %rdi
movq %r13, %rsi
callq 0x499986
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x54075e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x54075e
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, %eax
jne 0x54075e
movq %rbx, 0x10(%rsp)
movq %r13, %rdi
leaq 0x9079a(%rip), %rsi # 0x5d114f
leaq 0x907a1(%rip), %rdx # 0x5d115d
callq 0x209290
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5409f2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
movq 0x30(%rsp), %rbp
jne 0x54075e
jmp 0x540a9d
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x53b6f8
jmp 0x54075e
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x53bb64
jmp 0x54075e
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x53bfd0
jmp 0x54075e
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x53d810
jmp 0x54075e
movq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x4ad5ae
jmp 0x54075e
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x906e2(%rip), %rsi # 0x5d114f
leaq 0x906e9(%rip), %rdx # 0x5d115d
callq 0x209290
leaq 0x10(%rsp), %rsi
movq %rbp, %rdi
callq 0x4985f4
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x540a9d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbp, %rdi
callq 0x49edce
movq 0x38(%rsp), %r14
movl $0x18, %edi
callq 0x1a5230
leaq 0x78(%rbp), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x88, %rbp
incq (%rbp)
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x540ae6
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x540b08
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x540b2d
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x9cef1(%rip), %rsi # 0x5dda4d
leaq 0x9cf2b(%rip), %rdx # 0x5dda8e
leaq 0x10(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x19cbb4(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x19cb80(%rip), %rsi # 0x6dd710
movq 0x26b3c9(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x540c01
movl $0x10, %edi
callq 0x1a5680
movq %rax, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x9ce53(%rip), %rsi # 0x5dda11
leaq 0x9ce87(%rip), %rdx # 0x5dda4c
leaq 0x10(%rsp), %rdi
callq 0x209290
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1a53e0
leaq 0x19cb52(%rip), %rax # 0x6dd738
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x19cb1e(%rip), %rsi # 0x6dd710
movq 0x26b367(%rip), %rdx # 0x7abf60
movq %r14, %rdi
callq 0x1a5b00
jmp 0x540c39
jmp 0x540cad
jmp 0x540c39
jmp 0x540cad
jmp 0x540c4c
jmp 0x540c6d
jmp 0x540c39
jmp 0x540cad
jmp 0x540cad
jmp 0x540c39
jmp 0x540cad
jmp 0x540c39
jmp 0x540cad
jmp 0x540cad
jmp 0x540cad
jmp 0x540c39
jmp 0x540cad
jmp 0x540cad
jmp 0x540c39
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
jne 0x540c92
jmp 0x540cb0
jmp 0x540cad
jmp 0x540cad
movq %rax, %r15
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x540c66
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
testb %bpl, %bpl
jne 0x540c70
jmp 0x540cb0
movq %rax, %r15
movq %r14, %rdi
callq 0x1a6080
jmp 0x540cb0
jmp 0x540cad
jmp 0x540cad
jmp 0x540cad
movq %rax, %r15
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x540cb0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x540cb0
jmp 0x540cad
jmp 0x540cad
jmp 0x540cad
jmp 0x540cad
jmp 0x540cad
jmp 0x540cad
movq %rax, %r15
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x540cc7
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x540ce9
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x540d0e
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %r15, %rdi
callq 0x1a5b90
| /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_CHECK_RET("ccw", ccw, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("colorPerVertex", colorPerVertex, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("normalPerVertex", normalPerVertex, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_CHECK_RET("solid", solid, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_LOOPEND;
// if "USE" defined then find already defined element.
if(!use.empty())
{
MACRO_USE_CHECKANDAPPLY(def, use, ENET_TriangleSet, ne);
}
else
{
// create and if needed - define new geometry object.
ne = new CX3DImporter_NodeElement_IndexedSet(CX3DImporter_NodeElement::ENET_TriangleSet, NodeElement_Cur);
if(!def.empty()) ne->ID = def;
CX3DImporter_NodeElement_Set& ne_alias = *((CX3DImporter_NodeElement_Set*)ne);
ne_alias.CCW = ccw;
ne_alias.ColorPerVertex = colorPerVertex;
ne_alias.NormalPerVertex = normalPerVertex;
ne_alias.Solid = solid;
// check for child nodes
if(!mReader->isEmptyElement())
{
ParseHelper_Node_Enter(ne);
MACRO_NODECHECK_LOOPBEGIN("TriangleSet");
// check for X3DComposedGeometryNodes
if(XML_CheckNode_NameEqual("Color")) { ParseNode_Rendering_Color(); continue; }
if(XML_CheckNode_NameEqual("ColorRGBA")) { ParseNode_Rendering_ColorRGBA(); continue; }
if(XML_CheckNode_NameEqual("Coordinate")) { ParseNode_Rendering_Coordinate(); continue; }
if(XML_CheckNode_NameEqual("Normal")) { ParseNode_Rendering_Normal(); continue; }
if(XML_CheckNode_NameEqual("TextureCoordinate")) { ParseNode_Texturing_TextureCoordinate(); continue; }
// check for X3DMetadataObject
if(!ParseHelper_CheckRead_X3DMetadataObject()) XML_CheckNode_SkipUnsupported("TriangleSet");
MACRO_NODECHECK_LOOPEND("TriangleSet");
ParseHelper_Node_Exit();
}// if(!mReader->isEmptyElement())
else
{
NodeElement_Cur->Child.push_back(ne);// add made object as child to current element
}
NodeElement_List.push_back(ne);// add element to node element list because its a new object in graph
}// if(!use.empty()) else
} | 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), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %r14d
testl %eax, %eax
movq %rbp, 0x10(%rsp)
jle 0x540f6d
xorl %r15d, %r15d
movb $0x1, 0xf(%rsp)
leaq 0x18(%rsp), %r12
movb $0x1, 0xe(%rsp)
movb $0x1, 0xc(%rsp)
movb $0x1, 0xd(%rsp)
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x28(%rax)
movq %r12, %rdi
movq %rax, %rsi
leaq 0x3f(%rsp), %rdx
callq 0x23ca1c
movq %r12, %rdi
leaq 0x91746(%rip), %rsi # 0x5d24fd
callq 0x1a60c0
testl %eax, %eax
je 0x540e89
movq %r12, %rdi
leaq 0x2a45b(%rip), %rsi # 0x56b229
callq 0x1a60c0
testl %eax, %eax
je 0x540ea3
movq %r12, %rdi
leaq 0x8fb55(%rip), %rsi # 0x5d093a
callq 0x1a60c0
testl %eax, %eax
je 0x540edf
movq %r12, %rdi
leaq 0x8fb49(%rip), %rsi # 0x5d0945
callq 0x1a60c0
testl %eax, %eax
je 0x540edf
movq %r12, %rdi
leaq 0x8fb3b(%rip), %rsi # 0x5d094e
callq 0x1a60c0
testl %eax, %eax
je 0x540edf
movq %r12, %rdi
leaq 0x911d8(%rip), %rsi # 0x5d2002
callq 0x1a60c0
testl %eax, %eax
je 0x540f09
movq %r12, %rdi
leaq 0x911a2(%rip), %rsi # 0x5d1fe3
callq 0x1a60c0
testl %eax, %eax
je 0x540f1a
movq %r12, %rdi
leaq 0x9119a(%rip), %rsi # 0x5d1ff2
callq 0x1a60c0
testl %eax, %eax
je 0x540f2b
movq %r12, %rdi
leaq 0x5d997(%rip), %rsi # 0x59e806
callq 0x1a60c0
testl %eax, %eax
je 0x540f3c
movq %rbp, %rdi
movq %r12, %rsi
callq 0x498b92
jmp 0x540edf
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x48(%rsp), %rbp
jmp 0x540ebb
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x30(%rax)
movq %rax, %r13
leaq 0x68(%rsp), %rbp
movq 0x8(%rbp), %rbx
movq %r13, %rdi
callq 0x1a56a0
movq %rbp, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x1a5830
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x540efb
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
incl %r15d
cmpl %r15d, %r14d
jne 0x540d8d
jmp 0x540f4d
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0xf(%rsp)
jmp 0x540edf
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0xe(%rsp)
jmp 0x540edf
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0xd(%rsp)
jmp 0x540edf
movq %rbp, %rdi
movl %r15d, %esi
callq 0x499f12
movb %al, 0xc(%rsp)
jmp 0x540edf
andb $0x1, 0xf(%rsp)
andb $0x1, 0xe(%rsp)
andb $0x1, 0xd(%rsp)
andb $0x1, 0xc(%rsp)
leaq 0x78(%rsp), %r15
leaq 0x58(%rsp), %r12
jmp 0x540f81
movb $0x1, 0xd(%rsp)
movb $0x1, 0xc(%rsp)
movb $0x1, 0xe(%rsp)
movb $0x1, 0xf(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x540ff8
movq %rbp, %rdi
callq 0x4997b6
cmpq $0x0, 0x50(%rsp)
je 0x540fa1
movq %rbp, %rdi
callq 0x4989dc
leaq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rcx
movq %rbp, %rdi
movl $0x1f, %edx
callq 0x498494
testb %al, %al
jne 0x540fc9
leaq 0x68(%rsp), %rsi
movq %rbp, %rdi
callq 0x4994f4
movq 0x90(%rbp), %rbp
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbp), %rsi
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x48, %rbp
jmp 0x5414a8
movl $0xf0, %edi
callq 0x1a5230
movq %rax, %r14
movq 0x90(%rbp), %rax
movl $0x1f, 0x8(%r14)
leaq 0x20(%r14), %rcx
movq %rcx, 0x10(%r14)
xorl %ecx, %ecx
movq %rcx, 0x18(%r14)
movb $0x0, 0x20(%r14)
movq %rax, 0x30(%r14)
leaq 0x38(%r14), %rax
movq %rax, 0x40(%r14)
movq %rax, 0x38(%r14)
movq %rcx, 0x48(%r14)
leaq 0x50(%r14), %rax
movq %rax, 0x58(%r14)
movq %rax, 0x50(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movb $0x1, 0x70(%r14)
leaq 0x26a855(%rip), %rax # 0x7ab8b0
movq %rax, (%r14)
movups %xmm0, 0x78(%r14)
movq %rcx, 0x88(%r14)
movups %xmm0, 0x98(%r14)
movq %rcx, 0xa8(%r14)
movups %xmm0, 0xb8(%r14)
movq %rcx, 0xc8(%r14)
movq %rcx, 0xe8(%r14)
movups %xmm0, 0xd8(%r14)
movq %r14, 0x40(%rsp)
cmpq %rcx, 0x50(%rsp)
je 0x5410b4
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x48(%rsp), %rsi
callq 0x1a64a0
movb 0xf(%rsp), %al
movb %al, 0x71(%r14)
movb 0xe(%rsp), %al
movb %al, 0x72(%r14)
movb 0xd(%rsp), %al
movb %al, 0x73(%r14)
movb 0xc(%rsp), %al
movb %al, 0x70(%r14)
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
testb %al, %al
je 0x54110f
movq 0x90(%rbp), %rbx
movl $0x18, %edi
callq 0x1a5230
leaq 0x38(%rbx), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
incq 0x48(%rbx)
jmp 0x541487
movq %rbp, %rdi
movq %r14, %rsi
callq 0x49ed82
leaq 0x28(%rsp), %rbx
leaq 0x840a(%rip), %r15 # 0x549530
leaq 0x8408(%rip), %r12 # 0x549535
leaq 0x18(%rsp), %r13
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x541436
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x541368
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x209290
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5411a1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x5413dc
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
leaq 0x90da6(%rip), %rsi # 0x5d1f5e
leaq 0x90da8(%rip), %rdx # 0x5d1f67
callq 0x209290
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5411fa
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x5413ee
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
leaq 0x91d60(%rip), %rsi # 0x5d2f71
leaq 0x91d63(%rip), %rdx # 0x5d2f7b
callq 0x209290
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x541253
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x541400
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
leaq 0x91ce7(%rip), %rsi # 0x5d2f51
leaq 0x91ce6(%rip), %rdx # 0x5d2f57
callq 0x209290
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5412ac
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x541412
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
leaq 0x91ca7(%rip), %rsi # 0x5d2f6a
leaq 0x91cb1(%rip), %rdx # 0x5d2f7b
callq 0x209290
movq 0x10(%rsp), %rax
movq 0x98(%rax), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x541305
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
je 0x541424
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x4a4f84
testb %al, %al
jne 0x541132
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
leaq 0x8fe34(%rip), %rsi # 0x5d1165
leaq 0x8fe38(%rip), %rdx # 0x5d1170
callq 0x209290
movq %rbp, %rdi
movq %r13, %rsi
callq 0x499986
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x541132
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x541132
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, %eax
jne 0x541132
movq %rbx, 0x18(%rsp)
movq %r13, %rdi
leaq 0x8fdd8(%rip), %rsi # 0x5d1165
leaq 0x8fddc(%rip), %rdx # 0x5d1170
callq 0x209290
movq 0x98(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0x1a60c0
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5413ca
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
testl %ebp, %ebp
movq 0x10(%rsp), %rbp
jne 0x541132
jmp 0x541475
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x53b6f8
jmp 0x541132
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x53bb64
jmp 0x541132
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x53bfd0
jmp 0x541132
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x53d810
jmp 0x541132
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x4ad5ae
jmp 0x541132
leaq 0x18(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x8fd20(%rip), %rsi # 0x5d1165
leaq 0x8fd24(%rip), %rdx # 0x5d1170
callq 0x209290
leaq 0x18(%rsp), %rsi
movq %rbp, %rdi
callq 0x4985f4
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x541475
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %rbp, %rdi
leaq 0x78(%rsp), %r15
leaq 0x58(%rsp), %r12
callq 0x49edce
movl $0x18, %edi
callq 0x1a5230
leaq 0x78(%rbp), %rsi
movq %r14, 0x10(%rax)
movq %rax, %rdi
callq 0x1a5360
addq $0x88, %rbp
incq (%rbp)
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x5414c3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x5414da
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a5190
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54150c
jmp 0x541523
jmp 0x54150c
jmp 0x541523
jmp 0x541523
jmp 0x54150c
jmp 0x54150c
jmp 0x541523
jmp 0x541523
jmp 0x54150c
jmp 0x541523
jmp 0x541523
jmp 0x54150c
jmp 0x541523
jmp 0x541523
jmp 0x54150c
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x541526
jmp 0x541578
jmp 0x541523
jmp 0x541523
jmp 0x541523
jmp 0x541523
movq %rax, %r14
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x541542
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x54155e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1a5190
movq %r14, %rdi
callq 0x1a5b90
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x541526
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a5190
jmp 0x541526
nop
| /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);
b = (in[i] & 0x03) << 4;
if (i + 1 < inLength) {
b |= (in[i + 1] & 0xF0) >> 4;
out[j++] = EncodeCharBase64(b);
b = (in[i + 1] & 0x0F) << 2;
if (i + 2 < inLength) {
b |= (in[i + 2] & 0xC0) >> 6;
out[j++] = EncodeCharBase64(b);
b = in[i + 2] & 0x3F;
out[j++] = EncodeCharBase64(b);
}
else {
out[j++] = EncodeCharBase64(b);
out[j++] = '=';
}
}
else {
out[j++] = EncodeCharBase64(b);
out[j++] = '=';
out[j++] = '=';
}
}
} | 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, %r14
je 0x542a36
movl $0x2, %ecx
leaq 0x9b333(%rip), %rax # 0x5ddcb4
movzbl -0x2(%r15,%rcx), %edx
shrl $0x2, %edx
movb (%rdx,%rax), %dl
movq (%rbx), %rsi
movb %dl, (%rsi,%r12)
movzbl -0x2(%r15,%rcx), %edx
shll $0x4, %edx
andl $0x30, %edx
leaq -0x1(%rcx), %rsi
cmpq %r14, %rsi
jae 0x5429f4
movzbl -0x1(%r15,%rcx), %esi
shrl $0x4, %esi
orq %rdx, %rsi
movb (%rsi,%rax), %dl
movq (%rbx), %rsi
movb %dl, 0x1(%rsi,%r12)
movzbl -0x1(%r15,%rcx), %edx
shll $0x2, %edx
andl $0x3c, %edx
cmpq %r14, %rcx
jae 0x542a0a
movzbl (%r15,%rcx), %esi
shrl $0x6, %esi
orq %rdx, %rsi
movb (%rsi,%rax), %dl
movq (%rbx), %rsi
movb %dl, 0x2(%rsi,%r12)
movzbl (%r15,%rcx), %edx
andl $0x3f, %edx
movb (%rdx,%rax), %dl
jmp 0x542a17
movb (%rdx,%rax), %dl
movq (%rbx), %rsi
movb %dl, 0x1(%rsi,%r12)
movq (%rbx), %rdx
movb $0x3d, 0x2(%rdx,%r12)
jmp 0x542a15
movb (%rdx,%rax), %dl
movq (%rbx), %rsi
movb %dl, 0x2(%rsi,%r12)
movb $0x3d, %dl
movq (%rbx), %rsi
movb %dl, 0x3(%rsi,%r12)
addq $0x4, %r12
leaq 0x3(%rcx), %rdx
incq %rcx
cmpq %r14, %rcx
movq %rdx, %rcx
jb 0x542981
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 $0xde, %edx
callq 0x1a5270
nop
| /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;
}
} else if (points_[2] == p1) {
if (points_[0] == p2) {
return 1;
} else if (points_[1] == p2) {
return 0;
}
}
return -1;
} | 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
je 0x542fa2
cmpq %rdx, %rax
je 0x542f9c
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
movl $0x2, %eax
retq
xorl %eax, %eax
retq
nop
| /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), %rax
movsd 0x8(%rax), %xmm0
movq %r12, %rdi
callq 0x1a5df0
leaq 0x1c10d(%rip), %r12 # 0x55f30c
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a61e0
movq 0x10(%rbx), %rax
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x1a5df0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a61e0
movq 0x10(%rbx), %rax
movsd 0x8(%rax), %xmm0
movq %r13, %rdi
callq 0x1a5df0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1a61e0
movq 0x18(%rbx), %rax
movsd (%rax), %xmm0
movq %r15, %rdi
callq 0x1a5df0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1a61e0
movq 0x18(%rbx), %rax
movsd 0x8(%rax), %xmm0
movq %r15, %rdi
callq 0x1a5df0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1a6320
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1a5970
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1a5800
nop
| /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
if (deleteCallBack)
delete callback;
// create list with special characters
createSpecialCharacterList();
// set pointer to text begin
P = TextBegin;
} | 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, 0x38(%rdi)
movl $0x1, %edi
callq 0x1a57a0
movq %rax, 0x30(%rbx)
movb $0x0, (%rax)
movq $0x0, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movl $0x1, %edi
callq 0x1a57a0
movq %rax, 0x40(%rbx)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movw $0x101, %ax # imm = 0x101
movw %ax, 0x68(%rbx)
movups %xmm0, 0x70(%rbx)
movw %ax, 0x80(%rbx)
testq %r14, %r14
je 0x543870
leaq 0x58(%rbx), %r15
leaq 0x70(%rbx), %r12
movl $0x1, 0x2c(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x543b6e
testb %bpl, %bpl
je 0x543860
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x543c6c
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x54389f
movq %rax, %r14
movq %r12, %rdi
callq 0x543d9e
movq %r15, %rdi
callq 0x543e16
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x54389f
callq 0x1a5610
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x5438ad
callq 0x1a5610
movq %r14, %rdi
callq 0x1a5b90
nop
| /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
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
jmp 0x543ff5
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
| /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)
callq 0x1a5610
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
jmp 0x54404f
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
| /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 0x54436c
xorl %r13d, %r13d
movabsq $0x100000001, %rbp # imm = 0x100000001
movq $0x0, 0x8(%r15,%r13)
movq %rbp, 0x10(%r15,%r13)
movl $0x1, %edi
callq 0x1a57a0
movq %rax, 0x8(%r15,%r13)
movb $0x0, (%rax)
addq $0x10, %r13
cmpq %r13, %r14
jne 0x544343
addq $0x8, %r15
movq %r15, (%rbx)
movl 0xc(%rsp), %edx
movl %edx, 0x8(%rbx)
movl 0xc(%rbx), %eax
cmpl %edx, %eax
movl %edx, %ecx
cmovbl %eax, %ecx
testl %ecx, %ecx
jle 0x5443ac
movl %ecx, %r14d
xorl %r15d, %r15d
leaq (%r12,%r15), %rsi
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x54429e
addq $0x10, %r15
decq %r14
jne 0x54438e
movl 0x8(%rbx), %edx
movl 0xc(%rbx), %eax
cmpl %eax, %edx
jae 0x5443b3
movl %edx, 0xc(%rbx)
testq %r12, %r12
je 0x544404
leaq -0x8(%r12), %rbx
movq -0x8(%r12), %r14
testq %r14, %r14
je 0x5443e3
movq %r14, %r15
shlq $0x4, %r15
movq -0x10(%r12,%r15), %rdi
testq %rdi, %rdi
je 0x5443dd
callq 0x1a5610
addq $-0x10, %r15
jne 0x5443ce
shlq $0x4, %r14
orq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a5030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r13, %r13
je 0x544430
movq -0x8(%r15,%r13), %rdi
testq %rdi, %rdi
je 0x54442a
callq 0x1a5610
addq $-0x10, %r13
jne 0x54441b
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x1a5030
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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 && str2[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, %al
cmpl %ecx, %esi
je 0x544e7a
cmpb $0x0, (%rdx,%rdi)
jmp 0x544e77
cmpl %edi, %ecx
sete %al
retq
xorl %eax, %eax
retq
| /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;");
SpecialCharacters.push_back("\"quot;");
SpecialCharacters.push_back("'apos;");
} | 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, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x98abf(%rip), %rsi # 0x5de04a
movq %r14, %rdi
callq 0x545d60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x545ae4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5455ac
callq 0x1a5610
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x98a92(%rip), %rsi # 0x5de04f
movq %r14, %rdi
callq 0x545d60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x545ae4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5455de
callq 0x1a5610
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x98a65(%rip), %rsi # 0x5de054
movq %r14, %rdi
callq 0x545d60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x545ae4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x545610
callq 0x1a5610
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
leaq 0x98a3a(%rip), %rsi # 0x5de05b
movq %r14, %rdi
callq 0x545d60
movq %rbx, %rdi
movq %r14, %rsi
callq 0x545ae4
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x545642
callq 0x1a5610
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x545652
jmp 0x545652
jmp 0x545652
jmp 0x545652
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x545663
callq 0x1a5610
movq %rbx, %rdi
callq 0x1a5b90
nop
| /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 (sizeof(src_char_type) == sizeof(char_type))
{
// no need to convert
TextBegin = (char_type*)source;
TextData = (char_type*)pointerToStore;
TextSize = sizeWithoutHeader;
}
else
{
// convert source into target data format.
// TODO: implement a real conversion. This one just
// copies bytes. This is a problem when there are
// unicode symbols using more than one character.
TextData = new char_type[sizeWithoutHeader];
// MSVC debugger complains here about loss of data ...
size_t numShift = sizeof( char_type) * 8;
assert(numShift < 64);
const src_char_type cc = (src_char_type)(((uint64_t(1u) << numShift) - 1));
for (int i=0; i<sizeWithoutHeader; ++i)
TextData[i] = char_type( source[i] & cc);
TextBegin = TextData;
TextSize = sizeWithoutHeader;
// delete original data because no longer needed
delete [] pointerToStore;
}
} | 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
jne 0x5459a8
movq (%r15), %rax
testq %rax, %rax
je 0x5459a8
leaq 0x8(%r15), %rcx
movq %rax, %rdx
shrq $0x8, %rdx
shlq $0x8, %rax
orq %rdx, %rax
movq %rax, -0x8(%rcx)
movq (%rcx), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0x545984
jmp 0x5459a8
testb %al, %al
jne 0x545978
movl %ebp, %r12d
leaq (%r12,%r12), %rax
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x1a57a0
movq %rax, 0x8(%r14)
testl %ebp, %ebp
jle 0x5459e4
xorl %eax, %eax
movzwl (%r15,%rax,8), %ecx
movq 0x8(%r14), %rdx
movw %cx, (%rdx,%rax,2)
incq %rax
cmpq %rax, %r12
jne 0x5459cb
movq 0x8(%r14), %rax
movq %rax, 0x18(%r14)
movl %ebp, 0x20(%r14)
testq %rbx, %rbx
je 0x545a01
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1a5610
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/assimp/contrib/irrXML/CXMLReaderImpl.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.