name string | code string | asm string | file string |
|---|---|---|---|
Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation() | IfcShapeRepresentation() : Object("IfcShapeRepresentation") {} | pushq %rbx
movq %rdi, %rbx
leaq 0x38637d(%rip), %rax # 0x79a600
movq %rax, (%rdi)
leaq 0x38639b(%rip), %rax # 0x79a628
movq %rax, 0xa0(%rdi)
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x4142a9
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x4142... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h |
non-virtual thunk to Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation() | IfcShapeRepresentation() : Object("IfcShapeRepresentation") {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3862a9(%rip), %rax # 0x79a600
movq %rax, -0x80(%rdi)
leaq 0x3862c6(%rip), %rax # 0x79a628
movq %rax, 0x20(%rdi)
movq -0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x41437b
movq -0x8(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq -0x40(%rbx), %rdi
leaq -0x30(%rbx), %rax
cmpq %rax, %rdi
j... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h |
non-virtual thunk to Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation() | IfcShapeRepresentation() : Object("IfcShapeRepresentation") {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3861cd(%rip), %rax # 0x79a600
movq %rax, -0x90(%rdi)
leaq 0x3861e7(%rip), %rax # 0x79a628
movq %rax, 0x10(%rdi)
movq -0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x41445a
movq -0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq -0x50(%rbx), %rdi
leaq -0x40(%rbx), %rax
cmpq %rax, %rdi
... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h |
virtual thunk to Assimp::IFC::Schema_2x3::IfcShapeRepresentation::~IfcShapeRepresentation() | IfcShapeRepresentation() : Object("IfcShapeRepresentation") {} | pushq %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
leaq (%rdi,%rax), %rbx
leaq 0x3860df(%rip), %rcx # 0x79a600
movq %rcx, (%rdi,%rax)
leaq 0x3860fc(%rip), %rcx # 0x79a628
movq %rcx, 0xa0(%rdi,%rax)
movq 0x68(%rdi,%rax), %rdi
testq %rdi, %rdi
je 0x41454a
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h |
Assimp::IFC::Schema_2x3::IfcDistributionPort::IfcDistributionPort() | IfcDistributionPort() : Object("IfcDistributionPort") {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d1b04(%rip), %rax # 0x6e6a70
movq %rax, 0x148(%rdi)
xorl %r14d, %r14d
movq %r14, 0x150(%rdi)
leaq 0x1a2781(%rip), %rax # 0x5b7705
movq %rax, 0x158(%rdi)
leaq 0x385f46(%rip), %rsi # 0x79aed8
callq 0x415028
movq %r14, 0x118(%rbx)
leaq 0x385e2b(%rip), %rax ... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCReaderGen_2x3.h |
Assimp::IFC::(anonymous namespace)::Line::Eval(double) const | IfcVector3 Eval(IfcFloat u) const {
return p + u*v;
} | movq %rdi, %rax
movsd 0x40(%rsi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x28(%rsi), %xmm1
movupd 0x18(%rsi), %xmm2
movupd 0x30(%rsi), %xmm3
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, (%rdi)
movsd %xmm1, 0x10(%rdi)
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCCurve.cpp |
Assimp::IFC::CleanupWindowContour(Assimp::IFC::ProjectedWindowContour&) | void CleanupWindowContour(ProjectedWindowContour& window)
{
std::vector<IfcVector2> scratch;
std::vector<IfcVector2>& contour = window.contour;
ClipperLib::Polygon subject;
ClipperLib::Clipper clipper;
ClipperLib::ExPolygons clipped;
for(const IfcVector2& pip : contour) {
subject.push_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x40(%rsp)
xorl %eax, %eax
movq %rax, 0x50(%rsp)
movq %rax, 0x10(%rsp)
movapd %xmm0, (%rsp)
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x506202
xorpd %xmm0, %xmm... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCOpenings.cpp |
Assimp::IFC::FindLikelyCrossingLines(__gnu_cxx::__normal_iterator<Assimp::IFC::ProjectedWindowContour*, std::vector<Assimp::IFC::ProjectedWindowContour, std::allocator<Assimp::IFC::ProjectedWindowContour>>>) | void FindLikelyCrossingLines(ContourVector::iterator current)
{
SkipList& skiplist = (*current).skiplist;
IfcVector2 last_proj_point;
const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end();
for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) {
... | pushq %rbx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
cmpq %rsi, %rdx
je 0x43df2d
xorpd %xmm3, %xmm3
xorl %r8d, %r8d
movapd 0x122760(%rip), %xmm0 # 0x5605e0
movsd 0x188ca8(%rip), %xmm1 # 0x5c6b30
leaq 0x3f(%rax), %r9
movsd (%rdx,%r8), %xmm2
testq %r8, %r8
je... | /hbina[P]fatuous/thirdparty/assimp/code/Importer/IFC/IFCOpenings.cpp |
Assimp::FBXImporter::SetupProperties(Assimp::Importer const*) | void FBXImporter::SetupProperties(const Importer* pImp)
{
settings.readAllLayers = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_GEOMETRY_LAYERS, true);
settings.readAllMaterials = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_READ_ALL_MATERIALS, false);
settings.readMaterials = pImp->GetPropertyBool(AI_... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x17e6c6(%rip), %rsi # 0x5c7c05
movq %r14, %rdi
movl $0x1, %edx
callq 0x23ba82
testl %eax, %eax
setne 0x79(%rbx)
leaq 0x17e6d0(%rip), %rsi # 0x5c7c29
movq %r14, %rdi
xorl %edx, %edx
callq 0x23ba82
testl %eax, %eax
setne 0x7a(%rbx)
leaq 0x17e6d7... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXImporter.cpp |
Assimp::FBX::GetRequiredScope(Assimp::FBX::Element const&) | Scope::Scope(Parser& parser,bool topLevel)
{
if(!topLevel) {
TokenPtr t = parser.CurrentToken();
if (t->Type() != TokenType_OPEN_BRACKET) {
ParseError("expected open bracket",t);
}
}
TokenPtr n = parser.AdvanceToNextToken();
if(n == NULL) {
ParseError("unexpe... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x44ad33
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x17d74d(%rip), %rsi # 0x5c8493
leaq 0x17d75d(%rip), %rdx # 0x5c84aa
movq %rsp, %r14
movq %r14,... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXParser.cpp |
Assimp::FBX::FBXConverter::ConvertVideo(Assimp::FBX::Video const&) | unsigned int FBXConverter::ConvertVideo(const Video& video)
{
// generate empty output texture
aiTexture* out_tex = new aiTexture();
textures.push_back(out_tex);
// assuming the texture is compressed
out_tex->mWidth = static_cast<unsigned int>(video.C... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x428, %edi # imm = 0x428
callq 0x1a5230
movq %rax, %r15
xorl %r12d, %r12d
movq %r12, (%rax)
movq %r12, 0x18(%rax)
movl %r12d, 0x20(%rax)
movb $0x0, 0x24(%rax)
leaq 0x25(%rax), %rdi
movl $0x3ff, %edx ... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXConverter.cpp |
Assimp::FBX::ShapeGeometry::ShapeGeometry(unsigned long, Assimp::FBX::Element const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::FBX::Document const&) | ShapeGeometry::ShapeGeometry(uint64_t id, const Element& element, const std::string& name, const Document& doc)
: Geometry(id, element, name, doc) {
const Scope *sc = element.Compound();
if (nullptr == sc) {
DOMError("failed to read Geometry object (class: Shape), no data scope found");
}
const ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r13
movq %rdi, %rbx
callq 0x46ac14
leaq 0x331c3e(%rip), %rax # 0x79e890
movq %rax, (%rbx)
leaq 0x58(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x70(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x88(%rbx), %rax
movq %rax, 0x30(%rsp)
... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXMeshGeometry.cpp |
Assimp::FBX::LayeredTexture::fillTexture(Assimp::FBX::Document const&) | void LayeredTexture::fillTexture(const Document& doc)
{
const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
for(size_t i = 0; i < conns.size();++i)
{
const Connection* con = conns.at(i);
const Object* const ob = con->SourceObject();
if(!ob) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x467ae6
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x470138
leaq 0x38(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %r12
xorl %r14d, %r14d
leaq 0x10(%r... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXMaterial.cpp |
Assimp::FBX::Scope::FindElementCaseInsensitive(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const Element* FindElementCaseInsensitive(const std::string& elementName) const {
const char* elementNameCStr = elementName.c_str();
for (auto element = elements.begin(); element != elements.end(); ++element)
{
if (!ASSIMP_strincmp(element->first.c_str(), elementNameCStr, MAXLEN)) {
return element->second;... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x47186e
movq (%rsi), %r12
xorl %ebx, %ebx
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x4718a4
testq %r12, %r12
je 0x471885
movl $0x400, %edx # imm = 0x400
movq %r12, %rsi
callq 0x1a... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXParser.h |
Assimp::FBX::Model::~Model() | Model::~Model()
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x32c15f(%rip), %rax # 0x79ea10
movq %rax, (%rdi)
movq 0xc8(%rdi), %rdi
testq %rdi, %rdi
je 0x4728c5
callq 0x280464
movq 0xa0(%rbx), %rdi
leaq 0xb0(%rbx), %rax
cmpq %rax, %rdi
je 0x4728e3
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax,... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXModel.cpp |
Assimp::FBX::AnimationCurve::~AnimationCurve() | AnimationCurve::~AnimationCurve()
{
// empty
} | pushq %rbx
movq %rdi, %rbx
leaq 0x32b7fd(%rip), %rax # 0x79ea60
movq %rax, (%rdi)
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x473281
movq 0x90(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x473296
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x50(%rbx), %rdi
testq... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXAnimation.cpp |
Assimp::FBX::AnimationLayer::AnimationLayer(unsigned long, Assimp::FBX::Element const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::FBX::Document const&) | AnimationLayer::AnimationLayer(uint64_t id, const Element& element, const std::string& name, const Document& doc)
: Object(id, element, name)
, doc(doc)
{
const Scope& sc = GetRequiredScope(element);
// note: the props table here bears little importance and is usually absent
props = GetPropertyTable(doc,"A... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r8, %r15
movq %rdx, %r14
movq %rdi, %rbx
callq 0x465adc
leaq 0x32b1cc(%rip), %rax # 0x79ead0
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq %r15, 0x48(%rbx)
movq %r14, %rdi
callq 0x44ad17
movq %rax, %r12
leaq 0x20(%rsp)... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXAnimation.cpp |
Assimp::FBX::AnimationStack::AnimationStack(unsigned long, Assimp::FBX::Element const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::FBX::Document const&) | AnimationStack::AnimationStack(uint64_t id, const Element& element, const std::string& name, const Document& doc)
: Object(id, element, name)
{
const Scope& sc = GetRequiredScope(element);
// note: we don't currently use any of these properties so we shouldn't bother if it is missing
props = GetPropertyTab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x465adc
leaq 0x32ae65(%rip), %rax # 0x79eb08
movq %rax, (%rbx)
leaq 0x48(%rbx), %rax
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXAnimation.cpp |
Assimp::FBX::CameraSwitcher::~CameraSwitcher() | CameraSwitcher::~CameraSwitcher()
{
// empty
} | pushq %rbx
movq %rdi, %rbx
leaq 0x32a0c3(%rip), %rax # 0x79eb78
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x474ad3
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x474aeb
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq ... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXNodeAttribute.cpp |
Assimp::FBX::BlendShapeChannel::BlendShapeChannel(unsigned long, Assimp::FBX::Element const&, Assimp::FBX::Document const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BlendShapeChannel::BlendShapeChannel(uint64_t id, const Element& element, const Document& doc, const std::string& name)
: Deformer(id, element, doc, name)
{
const Scope& sc = GetRequiredScope(element);
const Element* const DeformPercent = sc["DeformPercent"];
if (DeformPercent) {
percent = Parse... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
callq 0x474bc4
leaq 0x329723(%rip), %rax # 0x79ed28
movq %rax, (%rbx)
leaq 0x50(%rbx), %r15
leaq 0x68(%rbx), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXDeformer.cpp |
Assimp::FBX::TokenizeBinary(std::vector<Assimp::FBX::Token const*, std::allocator<Assimp::FBX::Token const*>>&, char const*, unsigned long) | void TokenizeBinary(TokenList& output_tokens, const char* input, size_t length)
{
ai_assert(input);
if(length < 0x1b) {
TokenizeError("file is too short",0);
}
//uint32_t offset = 0x15;
/* const char* cursor = input + 0x15;
const uint32_t flags = ReadWord(input, cursor, input + length)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpq $0x1a, %rdx
jbe 0x476e2f
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x15101d(%rip), %rsi # 0x5c7d95
movl $0x12, %edx
movq %r14, %rdi
callq 0x1a53a0
testl %eax, %eax
jne 0x476e58
leaq 0x12(%r14), %rax
movq %rsp, %r12
movq %rax, (%r... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXBinaryTokenizer.cpp |
Assimp::FBX::(anonymous namespace)::TokenizeError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | AI_WONT_RETURN void TokenizeError(const std::string& message, size_t offset)
{
throw DeadlyImportError(Util::AddOffset("FBX-Tokenize",message,offset));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1517d8(%rip), %rsi # 0x5c86b3
leaq 0x1517dd(%rip), %rdx # 0x5c86bf
movq %rsp, %rdi
callq 0x209290
leaq 0x20(%r... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXBinaryTokenizer.cpp |
Assimp::FBX::(anonymous namespace)::ReadString(char const*&, char const*&, char const*, char const*&, char const*, bool, bool) | unsigned int ReadString(const char*& sbegin_out, const char*& send_out, const char* input,
const char*& cursor, const char* end, bool long_length = false, bool allow_null = false) {
const uint32_t len_len = long_length ? 4 : 1;
if(Offset(cursor, end) < len_len) {
TokenizeError("cannot ReadString... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %r8, %rax
subq (%rcx), %rax
movl %r9d, %ecx
leaq (%rcx,%rcx,2), %rcx
incq %rcx
cmpq %rcx, %rax
jb 0x477ac3
movq %r8, %r13
movq %rsi, %r12
movq %rdi, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r8, %rdx
testb %r9b... | /hbina[P]fatuous/thirdparty/assimp/code/FBX/FBXBinaryTokenizer.cpp |
Assimp::Q3DImporter::Face::Face(unsigned int) | explicit Face(unsigned int s)
: indices (s)
, uvindices (s)
, mat (0)
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x257162
leaq 0x18(%rbx), %rdi
leaq 0x6(%rsp), %rdx
movq %r14, %rsi
callq 0x257162
movl $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x47a61c
mo... | /hbina[P]fatuous/thirdparty/assimp/code/Q3D/Q3DLoader.h |
Assimp::Q3BSPFileImporter::findFirstMapInArchive(Assimp::ZipArchiveIOSystem&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool Q3BSPFileImporter::findFirstMapInArchive(ZipArchiveIOSystem &bspArchive, std::string &mapName ) {
mapName = "";
std::vector<std::string> fileList;
bspArchive.getFileListExtension( fileList, "bsp" );
if (fileList.empty()) {
return false;
}
std::vector<std::string>::iterator it( file... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdx), %rdx
leaq 0x12d3a2(%rip), %rcx # 0x5a8b41
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x1a5830
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x30(%rsp), %r15
movq %r1... | /hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileImporter.cpp |
Assimp::Q3BSPFileImporter::importTextureFromArchive(Assimp::Q3BSP::Q3BSPModel const*, Assimp::ZipArchiveIOSystem*, aiScene*, aiMaterial*, int) | bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model,
ZipArchiveIOSystem *archive, aiScene*,
aiMaterial *pMatHelper, int textureId ) {
if (nullptr == archive || nullptr == pMatHelper ) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp # imm = 0x478
testq %rdx, %rdx
sete %al
testq %r8, %r8
sete %cl
orb %al, %cl
testl %r9d, %r9d
sets %al
orb %cl, %al
jne 0x47cd2d
movq 0x78(%rsi), %rax
movq 0x80(%rsi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %r9d, %ecx
jle ... | /hbina[P]fatuous/thirdparty/assimp/code/Q3BSP/Q3BSPFileImporter.cpp |
UnknownChunk(Assimp::StreamReader<false, false>*, SIBChunk const&) | static void UnknownChunk(StreamReaderLE* /*stream*/, const SIBChunk& chunk)
{
char temp[5] = {
static_cast<char>(( chunk.Tag>>24 ) & 0xff),
static_cast<char>(( chunk.Tag>>16 ) & 0xff),
static_cast<char>(( chunk.Tag>>8 ) & 0xff),
static_cast<char>(chunk.Tag & 0xff), '\0'
};
A... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %edi, %eax
movl %edi, %ecx
shrl $0x18, %ecx
movb %cl, 0xb(%rsp)
movl %edi, %ecx
shrl $0x10, %ecx
movb %cl, 0xc(%rsp)
movb %ah, 0xd(%rsp)
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
callq 0x241234
movq %rax, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
cal... | /hbina[P]fatuous/thirdparty/assimp/code/SIB/SIBImporter.cpp |
ReadString(Assimp::StreamReader<false, false>*, unsigned int) | static aiString ReadString(StreamReaderLE *stream, uint32_t numWChars) {
if ( nullptr == stream || 0 == numWChars ) {
static const aiString empty;
return empty;
}
// Allocate buffers (max expansion is 1 byte -> 4 bytes for UTF-8)
std::vector<unsigned char> str;
str.reserve( numWChar... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
setne %al
testl %edx, %edx
setne %cl
testb %cl, %al
jne 0x482754
movb 0x359980(%rip), %al # 0x7dc098
testb %al, %al
je 0x48285d
movl 0x35956a(%rip), %eax # 0x7dbc90
movl $0x3ff, %r14d # imm = 0x3FF
... | /hbina[P]fatuous/thirdparty/assimp/code/SIB/SIBImporter.cpp |
Assimp::SMDImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
this->pScene = pScene;
ReadSmd(pFile, pIOHandler);
// If there are no triangles it seems to be an animation SMD,
// containing only the animation skeleton.
if (asTriangles.empty()) {
if (asB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, 0x98(%rdi)
movq %rcx, %rdx
callq 0x483e3a
movq 0xc0(%r14), %rax
cmpq 0xc8(%r14), %rax
jne 0x483c8a
movq 0xd8(%r14), %rax
cmpq 0xe0(%r14), %rax
je 0x483dab
orb $0x1, (%rbx)
m... | /hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp |
Assimp::SMDImporter::CreateOutputNodes() | void SMDImporter::CreateOutputNodes() {
pScene->mRootNode = new aiNode();
// now add all bones as dummy sub nodes to the graph
AddBoneChildren(pScene->mRootNode,(uint32_t)-1);
for (auto &bone : asBones) {
bone.mOffsetMatrix.Inverse();
}
// if we have only one bone we can even remove th... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r14
movq %rax, %rdi
callq 0x2402f8
movq 0x98(%rbx), %rax
movq %r14, 0x8(%rax)
movq 0x98(%rbx), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x4855a4
m... | /hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp |
Assimp::SMDImporter::GetAnimationFileList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, std::vector<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocat... | void SMDImporter::GetAnimationFileList(const std::string &pFile, IOSystem* pIOHandler, std::vector<std::tuple<std::string, std::string>>& outList) {
auto base = DefaultIOSystem::absolutePath(pFile);
auto name = DefaultIOSystem::completeBaseName(pFile);
auto path = base + "/" + name + "_animation.txt";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x120(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x100(%rsp), %rdi
callq 0x24d9bc
leaq 0x138(%rsp), %rdi
movq %r14, %rsi
callq 0x24d92a
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x100(%rsp), %... | /hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp |
Assimp::SMDImporter::ParseFile() | void SMDImporter::ParseFile() {
const char* szCurrent = &mBuffer[0];
// read line per line ...
for ( ;; ) {
if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) {
break;
}
// "version <n> \n", <n> should be 1 for hl and hl2 SMD files
if (TokenMatch(szCurrent,"version... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x80(%rdi), %rax
movq %rsp, %r12
movabsq $0x100002600, %rbp # imm = 0x100002600
movq (%rax), %r15
movl 0x104(%rbx), %r13d
leal 0x1(%r13), %eax
movl %eax, 0x104(%rbx)
movzbl (%r15), %r14d
cmpq $0x20, %r14
ja 0x48650e
b... | /hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp |
Assimp::SMDImporter::ParseTriangle(char const*, char const**) | void SMDImporter::ParseTriangle(const char* szCurrent, const char** szCurrentOut) {
asTriangles.push_back(SMD::Face());
SMD::Face& face = asTriangles.back();
if(!SkipSpaces(szCurrent,&szCurrent)) {
LogErrorNoThrow("Unexpected EOF/EOL while parsing a triangle");
return;
}
// read th... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, 0x8(%rsp)
movl $0x30, %eax
xorps %xmm0, %xmm0
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movups %xmm0, -0x10(%rsp,%rax)
movups %xmm0, -0x20(%rsp,%rax)
movq %rcx, (%rsp,%rax)... | /hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp |
Assimp::SMDImporter::ParseSkeletonElement(char const*, char const**, int) | void SMDImporter::ParseSkeletonElement(const char* szCurrent, const char** szCurrentOut,int iTime) {
aiVector3D vPos;
aiVector3D vRot;
unsigned int iBone = 0;
if(!ParseUnsignedInt(szCurrent,&szCurrent,iBone)) {
ASSIMP_LOG_ERROR("Unexpected EOF/EOL while parsing bone index");
SMDI_PARSE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %ecx, %r12d
movq %rsi, %r13
leaq 0x2c(%rsp), %rbx
xorl %eax, %eax
movq %rax, -0x4(%rbx)
leaq 0x30(%rsp), %rbp
movl %eax, (%rbp)
leaq 0x1c(%rsp), %rcx
movq %rax, -0x4(%rcx)
leaq 0x20(%rsp), %rcx
movl %eax, (%rcx)
movabsq $0x100000200... | /hbina[P]fatuous/thirdparty/assimp/code/SMD/SMDLoader.cpp |
Assimp::STLImporter::pushMeshesToNode(std::vector<unsigned int, std::allocator<unsigned int>>&, aiNode*) | void STLImporter::pushMeshesToNode( std::vector<unsigned int> &meshIndices, aiNode *node ) {
ai_assert( nullptr != node );
if ( meshIndices.empty() ) {
return;
}
node->mNumMeshes = static_cast<unsigned int>( meshIndices.size() );
node->mMeshes = new unsigned int[ meshIndices.size() ];
f... | pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x48b4dd
movq %rsi, %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0x48b4d5
movq %rdx, %r14
subq %rcx, %rax
shrq $0x2, %rax
movl %eax, 0x460(%rdx)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x1a57a0
movq %rax, 0x4... | /hbina[P]fatuous/thirdparty/assimp/code/STL/STLLoader.cpp |
Assimp::UnrealImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void UnrealImporter::InternReadFile( const std::string& pFile,
aiScene* pScene, IOSystem* pIOHandler)
{
// For any of the 3 files being passed get the three correct paths
// First of all, determine file extension
std::string::size_type pos = pFile.find_last_of('.');
std::string extension = GetExtens... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5d8, %rsp # imm = 0x5D8
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
movq %rsi, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x1a5730
movq %rax, %rbx
leaq 0xf8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq ... | /hbina[P]fatuous/thirdparty/assimp/code/Unreal/UnrealLoader.cpp |
Assimp::XFileImporter::CanRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*, bool) const | bool XFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
std::string extension = GetExtension(pFile);
if(extension == "x") {
return true;
}
if (!extension.length() || checkSig) {
uint32_t token[1];
token[0] = AI_MAKE_MAGIC("xof ");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x24818a
leaq 0xda85c(%rip), %rsi # 0x56978a
movq %r15, %rdi
callq 0x1a60c0
testl %eax, %eax
je 0x48ef74
cmpq $0x0, 0x10(%rsp)
setne %al
xorb $0x1, %bpl
testb %bpl,... | /hbina[P]fatuous/thirdparty/assimp/code/X/XFileImporter.cpp |
Assimp::XFileImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void XFileImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
// read file into memory
std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
if ( file.get() == NULL ) {
throw DeadlyImportError( "Failed to open file " + pFile + "." );
}
static co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x11b767(%rip), %rsi # 0x5aa761
leaq 0x11b762(%rip), %rdx # 0x5aa763
movq %rsp, %rdi
callq 0x209290
movq (%r12), %rsi... | /hbina[P]fatuous/thirdparty/assimp/code/X/XFileImporter.cpp |
Assimp::XFileParser::XFileParser(std::vector<char, std::allocator<char>> const&) | XFileParser::XFileParser( const std::vector<char>& pBuffer)
: mMajorVersion( 0 )
, mMinorVersion( 0 )
, mIsBinaryFormat( false )
, mBinaryNumCount( 0 )
, mP( nullptr )
, mEnd( nullptr )
, mLineNumber( 0 )
, mScene( nullptr ) {
// vector to store uncompressed file for INFLATE'd X files
std::vector<char> uncompre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl %eax, 0x28(%rdi)
movq %rax, 0x40(%rsp)
movaps %... | /hbina[P]fatuous/thirdparty/assimp/code/X/XFileParser.cpp |
Assimp::XFileParser::ParseUnknownDataObject() | void XFileParser::ParseUnknownDataObject()
{
// find opening delimiter
bool running = true;
while( running )
{
std::string t = GetNextToken();
if( t.length() == 0)
ThrowException( "Unexpected end of file while parsing unknown segment.");
if( t == "{")
bre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
leaq 0x106b4c(%rip), %r15 # 0x59af40
movq %r14, %rdi
movq %rbx, %rsi
callq 0x492c84
cmpq $0x0, 0x10(%rsp)
je 0x4944b8
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a60c0
movl %eax,... | /hbina[P]fatuous/thirdparty/assimp/code/X/XFileParser.cpp |
Assimp::XFileParser::ParseDataObjectMeshTextureCoords(Assimp::XFile::Mesh*) | void XFileParser::ParseDataObjectMeshTextureCoords( Mesh* pMesh)
{
readHeadOfDataObject();
if( pMesh->mNumTextures + 1 > AI_MAX_NUMBER_OF_TEXTURECOORDS)
ThrowException( "Too many sets of texture coordinates");
std::vector<aiVector2D>& coords = pMesh->mTexCoords[pMesh->mNumTextures++];
unsigned... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0x494556
movl 0x80(%r15), %r12d
leal 0x1(%r12), %eax
cmpl $0x9, %eax
jae 0x494e7a
movl %eax, 0x80(%r15)
movq %rbx, %rdi
callq 0x494a28
movl %eax, %r14d
movq 0x28(%r15), %rax
subq 0x20(%r15), %rax
sarq $0x2... | /hbina[P]fatuous/thirdparty/assimp/code/X/XFileParser.cpp |
Assimp::X3DImporter::FindNodeElement_FromRoot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CX3DImporter_NodeElement::EType, CX3DImporter_NodeElement**) | bool X3DImporter::FindNodeElement_FromRoot(const std::string& pID, const CX3DImporter_NodeElement::EType pType, CX3DImporter_NodeElement** pElement)
{
for(std::list<CX3DImporter_NodeElement*>::iterator it = NodeElement_List.begin(); it != NodeElement_List.end(); ++it)
{
if(((*it)->Type == pType) && ((*it)->ID == pI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x78(%rdi), %r13
addq $0x78, %r14
cmpq %r14, %r13
je 0x4983e8
movl %edx, %ebp
movq %rcx, (%rsp)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq 0x10(%r13), %rbx
cmpl %ebp, 0x8(%rbx)
jne 0x4983df
cmpq %r12, 0x18(%rbx)
jne 0x498... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::Throw_CloseNotFound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void X3DImporter::Throw_CloseNotFound(const std::string& pNode)
{
throw DeadlyImportError("Close tag for node <" + pNode + "> not found. Seems file is corrupt.");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movl $0x10, %edi
callq 0x1a5680
movq %rax, %rbx
leaq 0xfe5b0(%rip), %rsi # 0x596bc5
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x23ca59
leaq 0xfe5b1(%rip), %rsi # 0x596bda
leaq 0x8(%rsp), %rdi
callq 0x1a5ba0
leaq 0x38(%rsp), %r15
movq ... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::XML_SearchNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool X3DImporter::XML_SearchNode(const std::string& pNodeName)
{
while(mReader->read())
{
if((mReader->getNodeType() == irr::io::EXN_ELEMENT) && XML_CheckNode_NameEqual(pNodeName)) return true;
}
return false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x499f04
movq 0x98(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x1, %eax
jne 0x499efb
movq 0x98(%r14), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rbx, %rdi
movq %rax... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsCol3f(int, aiColor3D&) | void X3DImporter::XML_ReadNode_GetAttrVal_AsCol3f(const int pAttrIdx, aiColor3D& pValue)
{
std::vector<float> tlist;
std::vector<float>::iterator it;
XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);
if(tlist.size() != 3) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
it = tlist.begin();
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x49a78e
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
cmpq $0xc, %rax
jne 0x49a71a
movss (%rdi), %xmm0
movss %xmm0, (... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsArrF(int, std::vector<float, std::allocator<float>>&) | void X3DImporter::XML_ReadNode_GetAttrVal_AsArrF(const int pAttrIdx, std::vector<float>& pValue)
{
auto floatValue = std::dynamic_pointer_cast<const FIFloatValue>(mReader->getAttributeEncodedValue(pAttrIdx));
if (floatValue) {
pValue = floatValue->value;
}
else {
const char *val = mReade... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x98(%rdi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %edx
callq *0x90(%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x49a803
leaq 0x304ed3(%rip), %rsi # ... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsVec2f(int, aiVector2t<float>&) | void X3DImporter::XML_ReadNode_GetAttrVal_AsVec2f(const int pAttrIdx, aiVector2D& pValue)
{
std::vector<float> tlist;
std::vector<float>::iterator it;
XML_ReadNode_GetAttrVal_AsArrF(pAttrIdx, tlist);
if(tlist.size() != 2) Throw_ConvertFail_Str2ArrF(mReader->getAttributeValue(pAttrIdx));
it = tlist.begin();... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x49a78e
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
cmpq $0x8, %rax
jne 0x49a96b
movss (%rdi), %xmm0
movss %xmm0, (... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol3f(int, std::vector<aiColor3D, std::allocator<aiColor3D>>&) | void X3DImporter::XML_ReadNode_GetAttrVal_AsArrCol3f(const int pAttrIdx, std::vector<aiColor3D>& pValue)
{
std::list<aiColor3D> tlist;
XML_ReadNode_GetAttrVal_AsListCol3f(pAttrIdx, tlist);// read as list
// and copy to array
if(!tlist.empty())
{
pValue.reserve(tlist.size());
for(std::list<aiColor3D>::itera... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rdx
callq 0x49af26
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x49b0cd
movq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x4a0c24
movq %rbx, %r15
movq (%r15), %r15
cmpq ... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::XML_ReadNode_GetAttrVal_AsListS(int, std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | void X3DImporter::XML_ReadNode_GetAttrVal_AsListS(const int pAttrIdx, std::list<std::string>& pValue)
{
// make copy of attribute value - strings list.
const size_t tok_str_len = strlen(mReader->getAttributeValue(pAttrIdx));
if ( 0 == tok_str_len )
{
Throw_IncorrectAttrValue( mReader->getAttributeName... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %rdi
callq 0x1a56a0
testq %rax, %rax
je 0x49b88a
movq %rax, %r15
movq %r12, 0x10(%rsp)
movq 0x98(%r12), %rdi
movq (%rdi)... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::MeshGeometry_AddColor(aiMesh&, std::__cxx11::list<aiColor4t<float>, std::allocator<aiColor4t<float>>> const&, bool) const | void X3DImporter::MeshGeometry_AddColor(aiMesh& pMesh, const std::list<aiColor4D>& pColors, const bool pColorPerVertex) const
{
std::list<aiColor4D>::const_iterator col_it = pColors.begin();
if(pColorPerVertex)
{
if(pColors.size() < pMesh.mNumVertices)
{
throw DeadlyImportError("MeshGeometry_AddColor1. Co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq (%rdx), %r12
movq 0x10(%rdx), %rax
testl %ecx, %ecx
je 0x49c704
movl 0x4(%r14), %r13d
cmpq %r13, %rax
jb 0x49c7b4
movq %r13, %rbx
shlq $0x4, %rbx
movq %rbx, %rdi
callq 0x1a57a0
movq %rax, %r15
testq %... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
Assimp::X3DImporter::ParseFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Assimp::IOSystem*) | void X3DImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler)
{
std::unique_ptr<FIReader> OldReader = std::move(mReader);// store current XMLreader.
std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
// Check whether we can read from the file
if ( file.get() == nullptr )
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0x98(%rdi), %rbx
movq $0x0, 0x98(%rdi)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x10b942(%rip), %rsi # 0x5aa761
leaq 0x10b93d(%rip), %rdx # 0x5aa763
leaq 0x8(%rsp), %rdi... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter.cpp |
CX3DImporter_NodeElement::~CX3DImporter_NodeElement() | virtual ~CX3DImporter_NodeElement() {
// empty
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2fe753(%rip), %rax # 0x79f620
movq %rax, (%rdi)
leaq 0x38(%rdi), %r14
movq 0x38(%rdi), %rdi
cmpq %r14, %rdi
je 0x4a0ef2
movq (%rdi), %r15
movl $0x18, %esi
callq 0x1a5190
movq %r15, %rdi
cmpq %r14, %r15
jne 0x4a0edd
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %r... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Node.hpp |
Assimp::X3DImporter::ParseNode_Lighting_SpotLight() | void X3DImporter::ParseNode_Lighting_SpotLight()
{
std::string def, use;
float ambientIntensity = 0;
aiVector3D attenuation( 1, 0, 0 );
float beamWidth = 0.7854f;
aiColor3D color( 1, 1, 1 );
float cutOffAngle = 1.570796f;
aiVector3D direction( 0, 0, -1 );
bool global = true;
float in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdi, %rbx
leaq 0xa0(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movss 0xb6f... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Light.cpp |
Assimp::X3DImporter::ParseNode_MetadataSet() | void X3DImporter::ParseNode_MetadataSet()
{
std::string def, use;
std::string name, reference;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_RET("name", name, mReader->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("refe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %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 0xa8(%rsp), %rcx
movq %rcx, -0x1... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Metadata.cpp |
Assimp::X3DImporter::PostprocessHelper_ElementIsMesh(CX3DImporter_NodeElement::EType) const | bool X3DImporter::PostprocessHelper_ElementIsMesh(const CX3DImporter_NodeElement::EType pType) const
{
if((pType == CX3DImporter_NodeElement::ENET_Arc2D) || (pType == CX3DImporter_NodeElement::ENET_ArcClose2D) ||
(pType == CX3DImporter_NodeElement::ENET_Box) || (pType == CX3DImporter_NodeElement::ENET_Circle2D) ||
... | movd %esi, %xmm0
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movdqa 0x128473(%rip), %xmm1 # 0x5d0b90
paddd %xmm0, %xmm1
movl %esi, %eax
andl $-0x4, %eax
cmpl $0x18, %eax
sete %cl
movl %esi, %eax
andl $-0x3, %eax
cmpl $0x1c, %eax
pcmpeqd 0x128464(%rip), %xmm0 # 0x5d0ba0
sete %dl
pxor 0xb2b59(%rip), %xmm1 ... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Postprocess.cpp |
Assimp::X3DImporter::Postprocess_CollectMetadata(CX3DImporter_NodeElement const&, aiNode&) const | void X3DImporter::Postprocess_CollectMetadata(const CX3DImporter_NodeElement& pNodeElement, aiNode& pSceneNode) const
{
std::list<CX3DImporter_NodeElement*> meta_list;
size_t meta_idx;
PostprocessHelper_CollectMetadata(pNodeElement, meta_list);// find metadata in current node element.
if ( !meta_list.empty()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x468, %rsp # imm = 0x468
movq %rdx, 0x10(%rsp)
leaq 0x28(%rsp), %r15
movq %r15, 0x8(%r15)
movq %r15, (%r15)
movq $0x0, 0x10(%r15)
movq %r15, %rdx
callq 0x4a8682
movq 0x28(%rsp), %r14
cmpq %r15, %r14
je 0x4ab131
movq 0x10(%rsp), %rax
cmp... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Postprocess.cpp |
Assimp::X3DImporter::ParseNode_Texturing_ImageTexture() | void X3DImporter::ParseNode_Texturing_ImageTexture()
{
std::string use, def;
bool repeatS = true;
bool repeatT = true;
std::list<std::string> url;
CX3DImporter_NodeElement* ne( nullptr );
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECKUSEDEF_RET(def, use);
MACRO_ATTRREAD_CHECK_RET("repeatS", repe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x80(%rsp), %rcx
movq %rcx, 0x8(... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/X3DImporter_Texturing.cpp |
Assimp::FIShortValue::create(std::vector<short, std::allocator<short>>&&) | std::shared_ptr<FIShortValue> FIShortValue::create(std::vector<int16_t> &&value) {
return std::make_shared<FIShortValueImpl>(std::move(value));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x58, %edi
callq 0x1a5230
movq %rax, %r15
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0x2f1e16(%rip), %rax # 0x7a0168
movq %rax, (%r15)
leaq 0x10(%r15), %r12
leaq 0x18(%r15), %rdi
xorps %xmm... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIDoubleValue::create(std::vector<double, std::allocator<double>>&&) | std::shared_ptr<FIDoubleValue> FIDoubleValue::create(std::vector<double> &&value) {
return std::make_shared<FIDoubleValueImpl>(std::move(value));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x58, %edi
callq 0x1a5230
movq %rax, %r15
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0x2f1f88(%rip), %rax # 0x7a0530
movq %rax, (%r15)
leaq 0x10(%r15), %r12
leaq 0x18(%r15), %rdi
xorps %xmm... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FICDATAValue::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | std::shared_ptr<FICDATAValue> FICDATAValue::create(std::string &&value) {
return std::make_shared<FICDATAValueImpl>(std::move(value));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x1a5230
movq %rax, %r15
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r15)
leaq 0x2f1fdc(%rip), %rax # 0x7a0690
movq %rax, (%r15)
leaq 0x10(%r15), %r12
leaq 0x18(%r15), %rdi
leaq 0x28(... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIBase64Decoder::decode(unsigned char const*, unsigned long) | virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
return FIBase64Value::create(std::vector<uint8_t>(data, data + len));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq (%rcx,%rdx), %rax
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4b7f06
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x4ae29c
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIShortDecoder::decode(unsigned char const*, unsigned long) | virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
if (len & 1) {
throw DeadlyImportError(parseErrorMessage);
}
std::vector<int16_t> value;
size_t numShorts = len / 2;
value.reserve(numShorts);
for (size_t i = 0; i < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
testb $0x1, %r12b
jne 0x4aedce
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r12, %r15
shrq %r15
movq %r15, %rsi
callq 0x4b3f58
testq %r12, %r12
je 0x4... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIDoubleDecoder::decode(unsigned char const*, unsigned long) | virtual std::shared_ptr<const FIValue> decode(const uint8_t *data, size_t len) /*override*/ {
if (len & 7) {
throw DeadlyImportError(parseErrorMessage);
}
std::vector<double> value;
size_t numDoubles = len / 8;
value.reserve(numDoubles);
for (size_t i = 0; i <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
testb $0x7, %r12b
jne 0x4af3c9
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r12, %r15
shrq $0x3, %r15
movq %r15, %rsi
callq 0x419924
testq %r12, %r12
... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::CFIReaderImpl::parseElement() | void parseElement() {
// C.3
attributes.clear();
uint8_t b = *dataP;
bool hasAttributes = (b & 0x40) != 0; // C.3.3
if ((b & 0x3f) == 0x38) { // C.3.4.1
// Parse namespaces
++dataP;
for (;;) {
if (dataEnd - dataP < 1) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
addq $0x148, %rdi # imm = 0x148
movq 0x148(%rbx), %rsi
movq %rdi, 0x110(%rsp)
callq 0x4b4c38
movq 0x10(%rbx), %rdx
movzbl (%rdx), %ebp
movl %ebp, %eax
andl $0x3f, %eax
cmpl $0x38, %eax... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::CFIReaderImpl::parseSequenceLen() | size_t parseSequenceLen() { // C.21
if (dataEnd - dataP > 0) {
uint8_t b = *dataP++;
if (b < 0x80) { // 0....... (C.21.2)
return b;
}
else if ((b & 0xf0) == 0x80) { // 1000.... ........ ........ (C.21.3)
if (dataEnd - dataP > 1) {
... | pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x4b253a
leaq 0x1(%rcx), %rsi
movq %rsi, 0x10(%rdi)
movzbl (%rcx), %eax
testb %al, %al
js 0x4b24f6
movl %eax, %eax
jmp 0x4b2532
movl %eax, %r8d
andl $-0x10, %r8d
cmpl $0x80, %r8d
jne 0x4b253... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::CFIReaderImpl::parseNameSurrogate() | QName parseNameSurrogate() { // C.16
if (dataEnd - dataP < 1) {
throw DeadlyImportError(parseErrorMessage);
}
uint8_t b = *dataP++;
if (b & 0xfc) { // Padding '000000' C.2.5.5
throw DeadlyImportError(parseErrorMessage);
}
QName result;
size... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movq %rcx, %rax
subq %rdx, %rax
testq %rax, %rax
jle 0x4b2b04
movq %rsi, %r14
leaq 0x1(%rdx), %rax
movq %rax, 0x10(%rsi)
movb (%rdx), %bpl
cmpb $0x4, %bpl
jae 0x4b2b22
movq %rdi, %rbx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rd... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::CFIReaderImpl::QName::QName(Assimp::FIQName const&) | inline QName(const FIQName &qname): prefix(qname.prefix ? qname.prefix : ""), uri(qname.uri ? qname.uri : ""), name(qname.name) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
leaq 0xf5b0e(%rip), %rbp # 0x5a8b41
cmoveq %rbp, %r15
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq %r15, %rdi
callq 0x1a56a0
leaq (%rax,%r15), %rdx
movq %rbx, %rdi
movq ... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIHexValueImpl::toString[abi:cxx11]() const | virtual const std::string &toString() const /*override*/ {
if (!strValueValid) {
strValueValid = true;
std::ostringstream os;
os << std::hex << std::uppercase << std::setfill('0');
std::for_each(value.begin(), value.end(), [&](uint8_t c) { os << std::setw(2) << st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
cmpb $0x0, 0x40(%rdi)
jne 0x4b6672
movb $0x1, 0x40(%rbx)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x1a6170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x38(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIHexValueImpl::~FIHexValueImpl() | inline FIHexValueImpl(std::vector<uint8_t> &&value_): strValueValid(false) { value = std::move(value_); } | pushq %rbx
movq %rdi, %rbx
leaq 0x2e991f(%rip), %rax # 0x7a0028
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x4b6724
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
leaq 0x2e996d(%rip), %rax # 0x7a0098
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4b6743
movq 0x18(%r... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIShortValueImpl::toString[abi:cxx11]() const | virtual const std::string &toString() const /*override*/ {
if (!strValueValid) {
strValueValid = true;
std::ostringstream os;
int n = 0;
std::for_each(value.begin(), value.end(), [&](int16_t s) { if (++n > 1) os << ' '; os << s; });
strValue = os.str()... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
cmpb $0x0, 0x40(%rdi)
jne 0x4b6bd1
movb $0x1, 0x40(%rbx)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x1a6170
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %r14, %rcx
callq 0x4b6d0d
leaq 0x38(%rsp),... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIIntValueImpl::toString[abi:cxx11]() const | virtual const std::string &toString() const /*override*/ {
if (!strValueValid) {
strValueValid = true;
std::ostringstream os;
int n = 0;
std::for_each(value.begin(), value.end(), [&](int32_t i) { if (++n > 1) os << ' '; os << i; });
strValue = os.str()... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
cmpb $0x0, 0x40(%rdi)
jne 0x4b6e75
movb $0x1, 0x40(%rbx)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x1a6170
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %r14, %rcx
callq 0x4b6fb1
leaq 0x38(%rsp),... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIBoolValueImpl::toString[abi:cxx11]() const | virtual const std::string &toString() const /*override*/ {
if (!strValueValid) {
strValueValid = true;
std::ostringstream os;
os << std::boolalpha;
int n = 0;
std::for_each(value.begin(), value.end(), [&](bool b) { if (++n > 1) os << ' '; os << b; });
... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
cmpb $0x0, 0x50(%rdi)
jne 0x4b7469
movb $0x1, 0x50(%rbx)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x1a6170
movq (%r14), %rax
movq -0x18(%rax), %rax
orl $0x1, 0x48(%rsp,%rax)
leaq 0xc(%rsp), %r8
movl $0x0, (%r8)
movq 0x8(%rbx), %rdi
movq... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIDoubleValueImpl::toString[abi:cxx11]() const | virtual const std::string &toString() const /*override*/ {
if (!strValueValid) {
strValueValid = true;
std::ostringstream os;
int n = 0;
std::for_each(value.begin(), value.end(), [&](double d) { if (++n > 1) os << ' '; os << d; });
strValue = os.str();... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
cmpb $0x0, 0x40(%rdi)
jne 0x4b79bb
movb $0x1, 0x40(%rbx)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x1a6170
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %r14, %rcx
callq 0x4b7af7
leaq 0x38(%rsp),... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
Assimp::FIDoubleValueImpl::~FIDoubleValueImpl() | inline FIDoubleValueImpl(std::vector<double> &&value_): strValueValid(false) { value = std::move(value_); } | pushq %rbx
movq %rdi, %rbx
leaq 0x2e8b35(%rip), %rax # 0x7a0580
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x4b7a66
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
leaq 0x2e8b53(%rip), %rax # 0x7a05c0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4b7a85
movq 0x18(%r... | /hbina[P]fatuous/thirdparty/assimp/code/X3D/FIReader.cpp |
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&) | GenericValue(const std::basic_string<Ch>& s, Allocator& allocator) : data_() { SetStringRaw(StringRef(s), allocator); } | subq $0x18, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rax
movl 0x8(%rsi), %ecx
testq %rax, %rax
setne %sil
leaq 0x118d8d(%rip), %r8 # 0x5d7dc1
cmovneq %rax, %r8
movq %r8, 0x8(%rsp)
movl %ecx, 0x10(%rsp)
testl %ecx, %ecx
sete %al
orb %sil, %al
je 0x4bf05a
leaq 0x8(%rsp), %rsi
callq 0x4bf0d4
addq $0x... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/document.h |
glTF::Buffer::GetURI[abi:cxx11]() | std::string GetURI()
{ return std::string(this->id) + ".bin"; } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x20ac60
leaq 0x1138b4(%rip), %rsi # 0x5d42d3
movq %r14, %rdi
callq 0x1a5ba0
leaq 0x10(%rbx),... | /hbina[P]fatuous/thirdparty/assimp/code/glTF/glTFAsset.h |
rapidjson::internal::DisableIf<rapidjson::internal::RemoveSfinaeTag<rapidjson::internal::SfinaeTag& (*)(rapidjson::internal::OrExpr<rapidjson::internal::IsPointer<glTF::SamplerMagFilter>, rapidjson::internal::IsGenericValue<glTF::SamplerMagFilter>>)>::Type, rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::Memo... | AddMember(StringRefType name, T value, Allocator& allocator) {
GenericValue n(name);
return AddMember(n, value, allocator);
} | subq $0x28, %rsp
movl 0x8(%rsi), %eax
xorps %xmm0, %xmm0
movabsq $0x405000000000000, %r8 # imm = 0x405000000000000
orq (%rsi), %r8
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r8, 0x8(%rsi)
movl %eax, (%rsi)
leaq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movslq %edx, %rdx
movq %rdx, (%rax)
testl %edx, %edx
movl $0x1f6, %edx ... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/document.h |
rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(char const*, unsigned int) | GenericValue(const Ch* s, SizeType length) RAPIDJSON_NOEXCEPT : data_() { SetStringRaw(StringRef(s, length)); } | xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
testq %rsi, %rsi
setne %al
testl %edx, %edx
sete %cl
orb %al, %cl
je 0x4c8d13
testq %rsi, %rsi
leaq 0x10f0c6(%rip), %rax # 0x5d7dc1
cmovneq %rsi, %rax
movabsq $0x405000000000000, %rcx # imm = 0x405000000000000
orq %rax, %rcx
movq %rcx, 0x8(%rdi)
movl %edx, (%rdi)
retq
pushq %r... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/document.h |
rapidjson::internal::Stack<rapidjson::CrtAllocator>::ShrinkToFit() | void ShrinkToFit() {
if (Empty()) {
// If the stack is empty, completely deallocate the memory.
Allocator::Free(stack_);
stack_ = 0;
stackTop_ = 0;
stackEnd_ = 0;
}
else
Resize(GetSize());
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
je 0x4c8fc6
movq %rbx, %rdi
popq %rbx
jmp 0x4c886c
addq $0x10, %rbx
callq 0x1a52c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/../contrib/rapidjson/include/rapidjson/internal/stack.h |
o3dgc::SC3DMCDecoder<unsigned short>::SC3DMCDecoder() | SC3DMCDecoder(void)
{
m_iterator = 0;
m_streamSize = 0;
m_quantFloatArray = 0;
m_quantFloatArraySize... | pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
movl $0xc28, %edx # imm = 0xC28
xorl %esi, %esi
callq 0x1a54e0
movl $0x2, 0x103c(%rbx)
movl $0x1, 0x1038(%rbx)
movq $0xe, 0x20(%rbx)
movq $0x8, 0x28(%rbx)
movabsq $0x600000005, %rax # imm = 0x600000005
movq %rax, 0x830(%rbx)
movl $0x20e, %eax # imm ... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcSC3DMCDecoder.h |
o3dgc::AdjacencyInfo::AllocateNeighborsArray() | O3DGCErrorCode AllocateNeighborsArray()
{
for(long i = 1; i < m_numElements; ++i)
{
m_numNeighbors[i] += m_numNeighbors[i-1];
}
... | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
cmpq $0x2, %rcx
jl 0x4d6ef4
movl $0x1, %eax
movq 0x20(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdx
addq %rdx, (%rcx,%rax,8)
incq %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
jl 0x4d6edb
movq 0x20(%rbx), %rax
movq -0x8(%rax,%rcx,8), %rax
cmpq (%rbx), %rax
jle 0x4d6f3f
movq 0x18... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcAdjacencyInfo.h |
o3dgc::AdjacencyInfo::Begin(long) const | long Begin(long element) const
{
assert(element < m_numElements);
assert(element >= 0);
return (element>0)?m_numNeighbors[element-1]:0;
... | pushq %rax
cmpq %rsi, 0x10(%rdi)
jle 0x4d775b
testq %rsi, %rsi
js 0x4d777a
je 0x4d7757
movq 0x20(%rdi), %rax
movq -0x8(%rax,%rsi,8), %rax
jmp 0x4d7759
xorl %eax, %eax
popq %rcx
retq
leaq 0xff94c(%rip), %rdi # 0x5d70ae
leaq 0xff95d(%rip), %rsi # 0x5d70c6
leaq 0xff9df(%rip), %rcx # 0x5d714f
movl $0x7b, %edx
c... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcAdjacencyInfo.h |
o3dgc::Arithmetic_Codec::ExpGolombDecode(int, o3dgc::Static_Bit_Model&, o3dgc::Adaptive_Bit_Model&) | unsigned ExpGolombDecode(int k,
Static_Bit_Model & bModel0,
Adaptive_Bit_Model & bModel1)
{
unsigned int l;
int symbol = 0;
int binary_symbol = 0;
do
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r13d, %r13d
movl %esi, %r15d
movq %r14, %rdi
movq %r12, %rsi
callq 0x512668
movl $0x1, %edx
movl %r15d, %ecx
shll %cl, %edx
xorl %esi, %esi
cmpl $0x1, %eax
cmovnel %ebp, %ed... | /hbina[P]fatuous/thirdparty/assimp/code/../contrib/Open3DGC/o3dgcArithmeticCodec.h |
Assimp::glTF2Importer::ImportMaterials(glTF2::Asset&) | void glTF2Importer::ImportMaterials(glTF2::Asset& r)
{
const unsigned int numImportedMaterials = unsigned(r.materials.Size());
Material defaultMaterial;
mScene->mNumMaterials = numImportedMaterials + 1;
mScene->mMaterials = new aiMaterial*[mScene->mNumMaterials];
mScene->mMaterials[numImportedMater... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5b0(%rsi), %r12
subq 0x5a8(%rsi), %r12
shrq $0x3, %r12
leaq 0x8(%rsp), %rdi
callq 0x4e1c90
leal 0x1(%r12), %eax
movq 0xa8(%r14), %rcx
movl %eax, 0x20(%rcx)
movq 0xa8(%r14), %r15
movl ... | /hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Importer.cpp |
CreateNodeAnim(glTF2::Asset&, glTF2::Node&, AnimationSamplers&) | aiNodeAnim* CreateNodeAnim(glTF2::Asset& r, Node& node, AnimationSamplers& samplers)
{
aiNodeAnim* anim = new aiNodeAnim();
anim->mNodeName = GetNodeName(node);
static const float kMillisecondsFromSeconds = 1000.f;
if (samplers.translation) {
float* times = nullptr;
samplers.translatio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r12
movl $0x438, %edi # imm = 0x438
callq 0x1a5230
movq %rax, %r14
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
movl %ebx, (%rax)
movb $0x0, 0x4(%rax)
leaq 0x5(%rax), %rdi
movl $0x3ff, %edx # im... | /hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Importer.cpp |
glTF2::Buffer::SEncodedRegion::~SEncodedRegion() | ~SEncodedRegion() { delete[] DecodedData; } | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4dfa06
callq 0x1a5610
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x4dfa1f
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x1a5190
popq %rbx
retq
nop
| /hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Asset.h |
glTF2::Object::~Object() | virtual ~Object() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x2b304f(%rip), %rax # 0x7aa2d8
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x4f72a4
movq (%rax), %rsi
incq %rsi
callq 0x1a5190
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x4f72bd
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x1a5190
po... | /hbina[P]fatuous/thirdparty/assimp/code/glTF2/glTF2Asset.h |
Assimp::D3MFImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void D3MFImporter::InternReadFile( const std::string &filename, aiScene *pScene, IOSystem *pIOHandler ) {
D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename);
std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(opcPackage.RootStream()));
std::unique_ptr<D3MF::XmlReader> xmlReader... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rsp, %rdi
movq %rcx, %rsi
callq 0x4fafac
movl $0x30, %edi
callq 0x1a5230
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4fb7a2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x270a22
movq %rbx, %rdi
callq 0x543499
movq %rax, %r15
xorps %xmm0, %xmm0... | /hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp |
Assimp::D3MF::XmlSerializer::~XmlSerializer() | ~XmlSerializer() {
// empty
} | pushq %rbx
movq %rdi, %rbx
addq $0x50, %rdi
callq 0x31af3c
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x4f9904
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4f9919
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a5190
movq %rbx, %rdi
popq %rbx
jmp 0x4faf7a
| /hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp |
Assimp::D3MF::XmlSerializer::ReadObject(aiScene*) | aiNode* ReadObject(aiScene* scene) {
std::unique_ptr<aiNode> node(new aiNode());
std::vector<unsigned long> meshIds;
const char *attrib( nullptr );
std::string name, type;
attrib = xmlReader->getAttributeValue( D3MF::XmlTag::id.c_str() );
if ( nullptr != attrib ) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x478, %edi # imm = 0x478
callq 0x1a5230
movq %rax, %r15
movq %rax, %rdi
callq 0x2402f8
movq %r15, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rs... | /hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp |
Assimp::D3MF::XmlSerializer::ReadVertex() | aiVector3D ReadVertex() {
aiVector3D vertex;
vertex.x = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::x.c_str()), nullptr);
vertex.y = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::y.c_str()), nullptr);
vertex.z = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::z.c_st... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
movq 0x2e1d00(%rip), %rsi # 0x7dc308
movq (%rdi), %rax
callq *0x38(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testq %rax, %rax
je 0x4fa626
movq %rax, %rdi
callq 0x1a5f00
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x80(%rbx), %rdi
movq 0x2e... | /hbina[P]fatuous/thirdparty/assimp/code/3MF/D3MFImporter.cpp |
Assimp::MMDImporter::InternReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, aiScene*, Assimp::IOSystem*) | void MMDImporter::InternReadFile(const std::string &file, aiScene *pScene,
IOSystem * /*pIOHandler*/) {
// Read file by istream
std::filebuf fb;
if (!fb.open(file, std::ios::in | std::ios::binary)) {
throw DeadlyImportError("Failed to open file " + file + ".");
}
std::ist... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x340, %rsp # imm = 0x340
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x250(%rsp), %r12
movq %r12, %rdi
callq 0x1a5f70
movq (%r15), %rsi
movq %r12, %rdi
movl $0xc, %edx
callq 0x1a61a0
testq %rax, %rax
je 0x4fc136
leaq 0x138(%rsp), %rdi
lea... | /hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDImporter.cpp |
pmx::PmxMorphMaterialOffset::Read(std::istream*, pmx::PmxSetting*) | void PmxMorphMaterialOffset::Read(std::istream *stream, PmxSetting *setting)
{
this->material_index = ReadIndex(stream, setting->material_index_size);
stream->read((char*) &this->offset_operation, sizeof(uint8_t));
stream->read((char*)this->diffuse, sizeof(float) * 4);
stream->read((char*)this->specular, sizeo... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x4(%rdx), %esi
movq %rbx, %rdi
callq 0x4fdff8
movl %eax, 0x8(%r14)
leaq 0xc(%r14), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1a57e0
leaq 0x10(%r14), %rsi
movl $0x10, %edx
movq %rbx, %rdi
callq 0x1a57e0
leaq 0x20(%r14), %rsi
movl $0xc, %edx
movq... | /hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp |
pmx::PmxJointParam::Read(std::istream*, pmx::PmxSetting*) | void PmxJointParam::Read(std::istream *stream, PmxSetting *setting)
{
this->rigid_body1 = ReadIndex(stream, setting->rigidbody_index_size);
this->rigid_body2 = ReadIndex(stream, setting->rigidbody_index_size);
stream->read((char*) this->position, sizeof(float) * 3);
stream->read((char*) this->orientaiton, size... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x7(%rdx), %esi
movq %rbx, %rdi
callq 0x4fdff8
movl %eax, (%r14)
movzbl 0x7(%r15), %esi
movq %rbx, %rdi
callq 0x4fdff8
movl %eax, 0x4(%r14)
leaq 0x8(%r14), %rsi
movl $0xc, %edx
movq %rbx, %rdi
callq 0x1a57e0
leaq 0x14(%r14), %rsi
mo... | /hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp |
pmx::PmxModel::Init() | void PmxModel::Init()
{
this->version = 0.0f;
this->model_name.clear();
this->model_english_name.clear();
this->model_comment.clear();
this->model_english_comment.clear();
this->vertex_count = 0;
this->vertices = nullptr;
this->index_count = 0;
this->indices = nullptr;
this->texture_count = 0;
th... | pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, (%rdi)
movq %rax, 0x18(%rdi)
movq 0x10(%rdi), %rcx
movb %al, (%rcx)
movq %rax, 0x38(%rdi)
movq 0x30(%rdi), %rcx
movb %al, (%rcx)
movq %rax, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb %al, (%rcx)
movq %rax, 0x78(%rdi)
movq 0x70(%rdi), %rcx
movb %al, (%rcx)
movl %eax, 0x90... | /hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp |
pmx::PmxModel::Read(std::istream*) | void PmxModel::Read(std::istream *stream)
{
char magic[4];
stream->read((char*) magic, sizeof(char) * 4);
if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20)
{
std::cerr << "invalid magic number." << std::endl;
throw DeadlyImportError("MMD: invalid magic number.");
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x34(%rsp), %r15
movl $0x4, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x1a57e0
cmpl $0x20584d50, (%r15) # imm = 0x20584D50
jne 0x500102
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a5... | /hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDPmxParser.cpp |
mmd::_Unique_if<pmx::PmxRigidBody []>::_Unknown_bound mmd::make_unique<pmx::PmxRigidBody []>(unsigned long) | typename _Unique_if<T>::_Unknown_bound
make_unique(size_t n) {
typedef typename std::remove_extent<T>::type U;
return std::unique_ptr<T>(new U[n]());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0x88, %ecx
movq %rsi, %rax
mulq %rcx
seto %dl
addq $0x8, %rax
movq $-0x1, %rcx
cmovbq %rcx, %rax
movq %rdi, %rbx
testb %dl, %dl
cmoveq %rax, %rcx
movq %rcx, %rdi
callq 0x1a57a0
movq %r14, (%rax)
leaq 0x8(%rax), %rcx
testq %r14, %r14
je 0x5008cd
addq $0x38, %rax
mov... | /hbina[P]fatuous/thirdparty/assimp/code/MMD/MMDCpp14.h |
p2t::InScanArea(p2t::Point const&, p2t::Point const&, p2t::Point const&, p2t::Point const&) | bool InScanArea(const Point& pa, const Point& pb, const Point& pc, const Point& pd)
{
double oadb = (pa.x - pb.x)*(pd.y - pb.y) - (pd.x - pb.x)*(pa.y - pb.y);
if (oadb >= -EPSILON) {
return false;
}
double oadc = (pa.x - pc.x)*(pd.y - pc.y) - (pd.x - pc.x)*(pa.y - pc.y);
if (oadc <= EPSILON) {
return... | movsd (%rdi), %xmm2
movsd 0x8(%rdi), %xmm0
movsd (%rsi), %xmm4
movsd 0x8(%rsi), %xmm5
movapd %xmm2, %xmm6
subsd %xmm4, %xmm6
movsd (%rcx), %xmm3
movsd 0x8(%rcx), %xmm1
movapd %xmm1, %xmm7
subsd %xmm5, %xmm7
mulsd %xmm6, %xmm7
movapd %xmm3, %xmm6
subsd %xmm4, %xmm6
movapd %xmm0, %xmm4
subsd %xmm5, %xmm4
mulsd %xmm6, %xm... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/../common/utils.h |
p2t::Sweep::FlipEdgeEvent(p2t::SweepContext&, p2t::Point&, p2t::Point&, p2t::Triangle*, p2t::Point&) | void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p)
{
Triangle& ot = t->NeighborAcross(p);
Point& op = *ot.OppositePoint(*t, p);
if (InScanArea(p, *t->PointCCW(p), *t->PointCW(p), op)) {
// Lets rotate shared edge one vertex CW
RotateTrianglePair(*t, p, ot, op);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %r8, %r14
movq %rcx, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x543186
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x542e32... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc |
p2t::Sweep::AngleExceedsPlus90DegreesOrIsNegative(p2t::Point const*, p2t::Point const*, p2t::Point const*) const | bool Sweep::AngleExceedsPlus90DegreesOrIsNegative(const Point* origin, const Point* pa, const Point* pb) const {
const double angle = Angle(origin, pa, pb);
return (angle > PI_div2) || (angle < 0);
} | pushq %rax
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm2
movsd (%rdx), %xmm3
movsd 0x8(%rdx), %xmm4
subsd %xmm0, %xmm3
subsd %xmm2, %xmm4
movsd (%rcx), %xmm1
movsd 0x8(%rcx), %xmm5
subsd %xmm0, %xmm1
subsd %xmm2, %xmm5
movapd %xmm1, %xmm2
mulsd %xmm4, %xmm2
mulsd %xmm3, %xmm1
movapd %xmm3, %xmm0
mulsd %xmm5, %xmm0
subsd %... | /hbina[P]fatuous/thirdparty/assimp/contrib/poly2tri/poly2tri/sweep/sweep.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.