name string | code string | asm string | file string |
|---|---|---|---|
embree::SceneGraph::MultiTransformNode::get(unsigned long, float) const | virtual AffineSpace3ff get(size_t i, float time) const
{
if (spaces[i].size() <= 1) return spaces[i][0];
int numTimeSteps = spaces[i].size();
BBox1f time_range = spaces[i].time_range;
time = frac((time-time_range.lower)/time_range.size());
time = (numTimeSteps-1)*time;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x68(%rsi), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r14
movq 0x10(%rax,%rcx), %r15
cmpq $0x1, %r15
ja 0x5660a
movq 0x20(%r14), %rax
movaps (%rax), %xmm0
movaps %xmm0, (%rbx)
movaps 0x10(%rax), %xmm0
movaps %xmm0, 0x10(%rbx)
... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraph::SubdivMeshNode::bounds() const | virtual BBox3fa bounds() const
{
BBox3fa b = empty;
for (const auto& p : positions)
for (auto& x : p)
b.extend(x);
return b;
} | movq %rdi, %rax
movaps 0xf909c(%rip), %xmm0 # 0x1500a0
movaps %xmm0, (%rdi)
movaps 0xf90a2(%rip), %xmm1 # 0x1500b0
movaps %xmm1, 0x10(%rdi)
movq 0x70(%rsi), %rcx
movq 0x78(%rsi), %rdx
cmpq %rdx, %rcx
je 0x57057
movaps 0xf908a(%rip), %xmm1 # 0x1500b0
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x5704e
movq 0x18(%r... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraph::HairSetNode::bounds() const | virtual BBox3fa bounds() const
{
BBox3fa b = empty;
for (const auto& p : positions)
for (auto& x : p)
b.extend(x);
return b;
} | movq %rdi, %rax
movaps 0xf8db6(%rip), %xmm0 # 0x1500a0
movaps %xmm0, (%rdi)
movaps 0xf8dbc(%rip), %xmm1 # 0x1500b0
movaps %xmm1, 0x10(%rdi)
movq 0x78(%rsi), %rcx
movq 0x80(%rsi), %rdx
cmpq %rdx, %rcx
je 0x57340
movaps 0xf8da1(%rip), %xmm1 # 0x1500b0
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x57337
movq 0x18(%r... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraph::GridMeshNode::bounds() const | virtual BBox3fa bounds() const
{
BBox3fa b = empty;
for (const auto& p : positions)
for (auto& x : p)
b.extend(x);
return b;
} | movq %rdi, %rax
movaps 0xf88b8(%rip), %xmm0 # 0x1500a0
movaps %xmm0, (%rdi)
movaps 0xf88be(%rip), %xmm1 # 0x1500b0
movaps %xmm1, 0x10(%rdi)
movq 0x70(%rsi), %rcx
movq 0x78(%rsi), %rdx
cmpq %rdx, %rcx
je 0x5783b
movaps 0xf88a6(%rip), %xmm1 # 0x1500b0
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x57832
movq 0x18(%r... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraphFlattener::convertLightsAndCameras(std::vector<embree::Ref<embree::SceneGraph::Node>, std::allocator<embree::Ref<embree::SceneGraph::Node>>>&, embree::Ref<embree::SceneGraph::Node> const&, embree::SceneGraph::Transformations const&) | void convertLightsAndCameras(std::vector<Ref<SceneGraph::Node>>& group, const Ref<SceneGraph::Node>& node, const SceneGraph::Transformations& spaces)
{
if (!node->hasLightOrCamera) return;
if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>()) {
conver... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0xd0(%rsp)
movq (%rdx), %rdi
cmpb $0x1, 0x59(%rdi)
jne 0x6044a
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r13
testq %rdi, %rdi
je 0x5d4d2
leaq 0x170e79(%rip), %rsi # 0x1ce338
leaq 0x17107a(%rip), ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraphFlattener::lookupGeometries(embree::Ref<embree::SceneGraph::Node>) | Ref<SceneGraph::Node> lookupGeometries(Ref<SceneGraph::Node> node)
{
if (object_mapping.find(node) == object_mapping.end())
{
std::vector<Ref<SceneGraph::Node>> geometries;
convertGeometries(geometries,node,one);
object_mapping[node] = new SceneGraph::GroupNode(geometries);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x18(%rsi), %rdx
leaq 0x10(%rsi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x66af0
movq (%r14), %rsi
movq %rax, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::SubdivMeshNode::SubdivMeshNode(embree::Ref<embree::SceneGraph::SubdivMeshNode>, embree::SceneGraph::Transformations const&) | SubdivMeshNode (Ref<SceneGraph::SubdivMeshNode> imesh, const Transformations& spaces)
: Node(true),
time_range(imesh->time_range),
positions(transformMSMBlurVec3faBuffer(imesh->positions,spaces)),
normals(transformMSMBlurNormalBuffer(imesh->normals,spaces)),
texcoords(imesh->texc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x38(%rdi)... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraph::Transformations::interpolate(float) const | AffineSpace3ff interpolate (const float gtime) const
{
assert(time_range.lower == 0.0f && time_range.upper == 1.0f);
if (spaces.size() == 1) return spaces[0];
/* calculate time segment itime and fractional time ftime */
const int time_segments = int(spaces.size()-1);
const... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
cmpq $0x1, %r15
jne 0x6e736
movq 0x20(%r14), %rax
movaps (%rax), %xmm0
movaps %xmm0, (%rbx)
movaps 0x10(%rax), %xmm0
movaps %xmm0, 0x10(%rbx)
movaps 0x20(%rax), %xmm0
movaps %xmm0, 0x20(%rbx)
movaps 0x30(%rax), %xmm0... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraph::Transformations::lbounds(embree::LBBox<embree::Vec3fa> const&) const | LBBox3fa lbounds ( const LBBox3fa& cbounds ) const
{
assert(spaces.size());
if (spaces.size() == 1)
{
return LBBox3fa(xfmBounds(spaces[0],cbounds.bounds0),
xfmBounds(spaces[0],cbounds.bounds1));
}
else
{
avector<BBox3f... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %r12
cmpq $0x1, %r12
jne 0x6fc6f
movq 0x20(%r15), %rax
movaps (%rax), %xmm1
movaps 0x10(%rax), %xmm5
movaps 0x20(%rax), %xmm7
movaps 0x30(%rax), %xmm6
movaps (%r14), %xmm10
movups 0x4(%r14), %xm... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraph::createGarbageTriangleMesh(int, unsigned long, bool, embree::Ref<embree::SceneGraph::MaterialNode>) | Ref<SceneGraph::Node> SceneGraph::createGarbageTriangleMesh (int hash, size_t numTriangles, bool mblur, Ref<MaterialNode> material)
{
RandomSampler sampler;
RandomSampler_init(sampler,hash);
Ref<SceneGraph::TriangleMeshNode> mesh = new SceneGraph::TriangleMeshNode(material,BBox1f(0,1),mblur?2:1);
mes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, 0x8(%rsp)
movl %esi, %r13d
movq %rdi, 0x20(%rsp)
movl $0xd8, %edi
callq 0x17bb0
movq %rax, %r12
movq %rax, %rbx
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x754c9
movq (%rdi), %r... | /embree[P]embree/tutorials/common/scenegraph/geometry_creation.cpp |
embree::Vec2<float> embree::XMLLoader::load<embree::Vec2<float>>(embree::Ref<embree::XML> const&) | Vec2f XMLLoader::load<Vec2f>(const Ref<XML>& xml) {
if (xml->body.size() != 2) THROW_RUNTIME_ERROR(xml->loc.str()+": wrong float2 body");
return Vec2f(xml->body[0].Float(),xml->body[1].Float());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x98(%rax), %rdi
movq 0xa0(%rax), %rax
subq %rdi, %rax
cmpq $0x90, %rax
jne 0x78031
movl $0x1, %esi
callq 0x8f976
movss %xmm0, 0x4(%rsp)
movq (%r14), %rax
movq 0x98(%rax), %rdi
addq $0x48, %rdi
movl $0x1,... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadVec3fArray(embree::Ref<embree::XML> const&) | std::vector<Vec3f> XMLLoader::loadVec3fArray(const Ref<XML>& xml)
{
if (!xml) return std::vector<Vec3f>();
if (xml->parm("ofs") != "") {
return loadBinary<std::vector<Vec3f>>(xml);
}
else
{
std::vector<Vec3f> data;
if (xml->body.size() % 3 != 0) THROW_RUNTIME_ERROR(xml->loc.st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdx), %r12
testq %r12, %r12
je 0x7ac0d
movq %rdx, %r14
movq %rsi, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xdcb89(%rip), %rsi # 0x157724
leaq 0xdcb85(%rip), %rdx # 0x157727
leaq 0x8(%rsp), %r... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadUIntArray(embree::Ref<embree::XML> const&) | std::vector<unsigned> XMLLoader::loadUIntArray(const Ref<XML>& xml)
{
if (!xml) return std::vector<unsigned>();
if (xml->parm("ofs") != "") {
return loadBinary<std::vector<unsigned>>(xml);
}
else
{
std::vector<unsigned> data;
data.resize(xml->body.size());
for (size_t i=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdx), %r12
testq %r12, %r12
je 0x7bf67
movq %rdx, %r14
movq %rsi, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xdb82f(%rip), %rsi # 0x157724
leaq 0xdb82b(%rip), %rdx # 0x157727
leaq 0x8(%rsp), %r... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadSpotLight(embree::Ref<embree::XML> const&) | Ref<SceneGraph::Node> XMLLoader::loadSpotLight(const Ref<XML>& xml)
{
const AffineSpace3fa space = load<AffineSpace3fa>(xml->child("AffineSpace"));
const Vec3fa I = load<Vec3fa>(xml->child("I"));
const Vec3fa P = Vec3fa(zero);
const Vec3fa D = Vec3fa(0,0,1);
const float angleMin = load<float>(xml... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movabsq $0x7053656e69666641, %rax # imm = 0x7053656E69666641
movq %rax, (%r15)
movl $0x65636170, 0x7(%r15) # imm = 0x65636170
movq $0xb, -0x8(%r15)
movb $0x0, 0xb(%r15)
leaq ... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadQuadLight(embree::Ref<embree::XML> const&) | Ref<SceneGraph::Node> XMLLoader::loadQuadLight(const Ref<XML>& xml)
{
const AffineSpace3fa space = load<AffineSpace3fa>(xml->child("AffineSpace"));
const Vec3fa L = load<Vec3fa>(xml->child("L"));
const Vec3fa v0 = xfmPoint(space, Vec3fa(0, 0, 0));
const Vec3fa v1 = xfmPoint(space, Vec3fa(0, 1, 0));
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movabsq $0x7053656e69666641, %rax # imm = 0x7053656E69666641
movq %rax, (%r15)
movl $0x65636170, 0x7(%r15) # imm = 0x65636170
movq $0xb, -0x8(%r15)
movb $0x0, 0xb(%r15)
leaq ... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadAnimatedPerspectiveCamera(embree::Ref<embree::XML> const&) | Ref<SceneGraph::Node> XMLLoader::loadAnimatedPerspectiveCamera(const Ref<XML>& xml)
{
size_t numCameras = xml->size();
if (numCameras == 0)
return nullptr;
std::vector<Ref<SceneGraph::PerspectiveCameraNode>> cameras(numCameras);
for (size_t i=0; i<numCameras; i++)
cameras[i] = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq %rdx, 0x30(%rsp)
movq (%rdx), %rax
movq 0x88(%rax), %r15
subq 0x80(%rax), %r15
je 0x7ed63
movq %r14, 0x48(%rsp)
sarq $0x3, %r15
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
callq 0x6c8cc
cmpq $0x1, %r1... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadQuadMesh(embree::Ref<embree::XML> const&) | Ref<SceneGraph::Node> XMLLoader::loadQuadMesh(const Ref<XML>& xml)
{
Ref<SceneGraph::MaterialNode> material = loadMaterial(xml->child("material"));
Ref<SceneGraph::QuadMeshNode> mesh = new SceneGraph::QuadMeshNode(material,BBox1f(0,1),0);
if (Ref<XML> animation = xml->childOpt("animated_positions")) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x58(%rsp)
movq %rdi, %r14
movq %rdx, 0x60(%rsp)
movq (%rdx), %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xd6621(%rip), %rsi # 0x15833c
leaq 0xd6622(%rip), %rdx # 0x158344
leaq 0x10(%rsp), %rdi
callq 0x1e8d... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadTransform2Node(embree::Ref<embree::XML> const&) | Ref<SceneGraph::Node> XMLLoader::loadTransform2Node(const Ref<XML>& xml)
{
AffineSpace3fa space0 = load<AffineSpace3fa>(xml->children[0]);
AffineSpace3fa space1 = load<AffineSpace3fa>(xml->children[1]);
if (xml->size() == 3)
return new SceneGraph::TransformNode(space0,space1,loadNode(xml->children... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x80(%rax), %rdx
leaq 0x60(%rsp), %rdi
callq 0x78746
movq (%r12), %rax
movq 0x80(%rax), %rdx
addq $0x8, %rdx
leaq 0x20(%rsp), %rdi
callq 0x78746
movq (%r12), %rax
mov... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XMLLoader::loadBGFGroupNode(embree::Ref<embree::XML> const&) | Ref<SceneGraph::Node> XMLLoader::loadBGFGroupNode(const Ref<XML>& xml)
{
const size_t N = atoi(xml->parm("numChildren").c_str());
if (xml->body.size() != N)
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid group node");
Ref<SceneGraph::GroupNode> group = new SceneGraph::GroupNode(N);
for (size_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movq %rdx, (%rsp)
movq (%rdx), %rbx
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc9a2e(%rip), %rsi # 0x158027
leaq 0xc9a32(%rip), %rdx # 0x158032
leaq 0x38(%rsp), %rdi
callq 0x1e8d0
lea... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::Token::Float(bool) const | float Float(bool cast = true) const {
if (ty == TY_FLOAT) return f;
if (ty == TY_INT && cast) return (float)i;
THROW_RUNTIME_ERROR(loc.str()+": float expected");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x8f997
cmpl $0x3, %eax
jne 0x8f9ad
movss 0x4(%r14), %xmm0
jmp 0x8f9a2
testb %sil, %sil
je 0x8f9ad
cvtsi2ssl 0x4(%r14), %xmm0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
c... | /embree[P]embree/tutorials/common/scenegraph/../../../common/lexers/tokenstream.h |
std::vector<float, std::allocator<float>> embree::XMLLoader::loadBinary<std::vector<float, std::allocator<float>>>(embree::Ref<embree::XML> const&) | Vector XMLLoader::loadBinary(const Ref<XML>& xml)
{
if (!binFile)
THROW_RUNTIME_ERROR("cannot open file "+binFileName.str()+" for reading");
size_t ofs = atol(xml->parm("ofs").c_str());
fseek(binFile,long(ofs),SEEK_SET);
/* read size of array */
size_t size = atol(xml->parm("size").c_str(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
cmpq $0x0, 0x20(%rsi)
je 0x8fd2e
movq %rdx, %r12
movq (%rdx), %r15
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0xc7b77(%rip), %rsi # 0x157724
leaq 0xc7b73(%rip), %rdx # 0x157727
movq %r... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XML::parm_float(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | float parm_float(const std::string& parmID) const {
std::map<std::string,std::string>::const_iterator i = parms.find(parmID);
if (i == parms.end()) THROW_RUNTIME_ERROR (loc.str()+": XML node has no parameter \"" + parmID + "\"");
return std::stof(i->second);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x50, %rdi
callq 0x9489c
leaq 0x58(%r15), %rcx
cmpq %rcx, %rax
je 0x93339
movq 0x40(%rax), %r14
callq 0x17090
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
... | /embree[P]embree/tutorials/common/scenegraph/xml_parser.h |
embree::Parms::getVec3fa(char const*, embree::Vec3fa const&) const | Vec3fa getVec3fa(const char* name, const Vec3fa& def = zero) const {
std::map<std::string,Variant>::const_iterator i = m.find(name);
if (i == m.end() || (*i).second.type != Variant::FLOAT3) return def;
return (*i).second.getVec3fa();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rax
movq %r12, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x17450
movq %r15, %rdi
movq %r12, %rsi
callq 0x94dba
movq %rax, %r12
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
... | /embree[P]embree/tutorials/common/scenegraph/xml_loader.cpp |
embree::XML::childOpt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const Ref<XML> childOpt(const std::string& childID) const
{
for (size_t i=0; i<children.size(); i++)
if (children[i]->name == childID) return children[i];
return null;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
movq 0x80(%rsi), %rbx
movq 0x88(%rsi), %r13
subq %rbx, %r13
setne %bpl
je 0x93ca7
sarq $0x3, %r13
movq (%rdx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdx), %r14
xorl %edi, %edi
cmpq $0x1, %r13
sbbq %r13, %rdi
movl $0x1, %... | /embree[P]embree/tutorials/common/scenegraph/xml_parser.h |
embree::DielectricMaterial::~DielectricMaterial() | struct PREFIX(DielectricMaterial) MATERIAL_BASE_CLASS
{
#if !defined(ISPC) && !defined(CPPTUTORIAL)
DielectricMaterial (const Vec3fa& transmissionOutside, const Vec3fa& transmissionInside, const float etaOutside, const float etaInside)
: base(MATERIAL_DIELECTRIC), transmissionOutside(transmissionOutside), t... | pushq %rbx
movq %rdi, %rbx
callq 0x34eac
movq %rbx, %rdi
callq 0xd8839
popq %rbx
retq
movq %rax, %rdi
callq 0x1a679
nop
| /embree[P]embree/tutorials/common/scenegraph/materials.h |
embree::operator<(embree::Ref<embree::XML> const&, embree::Ref<embree::XML> const&) | bool operator <( const Ref<XML>& a, const Ref<XML>& b ) {
if (a->name != b->name ) return a->name < b->name;
if (a->parms != b->parms ) return a->parms < b->parms;
if (a->children != b->children) return a->children < b->children;
if (a->body != b->body ) return a->body ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
leaq 0x30(%r15), %r12
movq (%rsi), %rbp
leaq 0x30(%rbp), %r13
movq 0x38(%r15), %rdx
cmpq 0x38(%rbp), %rdx
jne 0x969e4
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x96a01
movq (%r13), %rsi
movq (%r12), %rdi
callq 0x17c... | /embree[P]embree/tutorials/common/scenegraph/xml_parser.h |
embree::XMLWriter::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long) | void XMLWriter::open(std::string str, size_t id)
{
tab(); xml << "<" << str << " id=\"" << id << "\">" << std::endl;
ident+=2;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x420(%rdi)
je 0x97f99
leaq 0x10(%rbx), %r12
xorl %ebp, %ebp
leaq 0xb71e7(%rip), %r13 # 0x14f164
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x17d70
incq %rbp
cmpq 0x420(... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
embree::XMLWriter::store_array_binary(char const*, embree::vector_t<embree::Vec3fx, embree::aligned_allocator<embree::Vec3fx, 16ul>> const&) | void XMLWriter::store_array_binary(const char* name, const avector<Vec3ff>& vec)
{
std::streampos offset = bin.tellg();
tab(); xml << "<" << name << " ofs=\"" << offset << "\" size=\"" << vec.size() << "\"/>" << std::endl;
for (size_t i=0; i<vec.size(); i++) bin.write((char*)&vec[i],sizeof(Vec3ff));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
addq $0x210, %rdi # imm = 0x210
callq 0x186c0
movq %rax, (%rsp)
cmpq $0x0, 0x420(%r14)
je 0x98dfa
leaq 0x10(%r14), %r13
xorl %r15d, %r15d
leaq 0xb6386(%rip), %rbp # 0x14f164
movl $... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
embree::XMLWriter::store(embree::SceneGraph::SpotLight const&, long) | void XMLWriter::store(const SceneGraph::SpotLight& light, ssize_t id)
{
open("SpotLight",id);
store("AffineSpace",AffineSpace3fa(frame(light.D),light.P));
store("I",light.I);
store("angleMin",light.angleMin);
store("angleMax",light.angleMax);
close("SpotLight");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xbdcd3(%rip), %rsi # 0x157846
leaq 0xbdcd5(%rip), %rdx # 0x15784f
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x1e8d0
movq %rbx, %rdi
movq %r... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
embree::XMLWriter::store(embree::Ref<embree::SceneGraph::Node>) | void XMLWriter::store(Ref<SceneGraph::Node> node)
{
if (nodeMap.find(node) != nodeMap.end()) {
tab(); xml << "<ref id=\"" << nodeMap[node] << "\"/>" << std::endl; return;
}
const ssize_t id = nodeMap[node] = currentNodeID++;
if (node->fileName != "") {
tab(); xml << "<extern id=\"" <<... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r12
movq %rdi, %rbp
movq 0x440(%rdi), %rdx
leaq 0x438(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x9aee6
movq (%r12), %rsi
movq %rax, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
embree::XMLWriter::store(embree::Ref<embree::MirrorMaterial>, long) | void XMLWriter::store(Ref<MirrorMaterial> material, ssize_t id)
{
open("material",id,material->name);
store("code","Mirror");
open("parameters");
store_parm("reflectance",material->reflectance);
close("parameters");
close("material");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xbc96a(%rip), %rsi # 0x15833c
leaq 0xbc96b(%rip), %rdx # 0x158344
leaq 0x20(%rsp), %rdi
callq 0x1e8d0
movq (%r14), %rax
leaq 0x10(%rsp), %r13... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
embree::XMLWriter::store(embree::Ref<embree::DielectricMaterial>, long) | void XMLWriter::store(Ref<DielectricMaterial> material, ssize_t id)
{
open("material",id,material->name);
store("code","Dielectric");
open("parameters");
store_parm("transmissionOutside",material->transmissionOutside);
store_parm("transmission",material->transmissionInside);
store_parm("etaOut... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xbbcbc(%rip), %rsi # 0x15833c
leaq 0xbbcbd(%rip), %rdx # 0x158344
leaq 0x20(%rsp), %rdi
callq 0x1e8d0
movq (%r14), %rax
leaq 0x10(%rsp), %r13... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
embree::XMLWriter::store(embree::Ref<embree::SceneGraph::TransformNode>, long) | void XMLWriter::store(Ref<SceneGraph::TransformNode> node, ssize_t id)
{
if (node->spaces.size() == 1)
{
open("Transform",id);
store("AffineSpace",node->spaces[0]);
store(node->child);
close("Transform");
}
else
{
open("TransformAnimation",id);
for (size_t i=0;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq $0x1, 0x78(%rax)
jne 0x9f435
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xb8bd8(%rip), %rsi # 0x157f2d
leaq 0xb8bda(%rip), %rdx # 0x157f36
leaq 0x70(%r... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
void embree::XMLWriter::store_array_binary<unsigned int>(char const*, std::vector<unsigned int, std::allocator<unsigned int>> const&) | void XMLWriter::store_array_binary(const char* name, const std::vector<T>& vec)
{
std::streampos offset = bin.tellg();
tab(); xml << "<" << name << " ofs=\"" << offset << "\" size=\"" << vec.size() << "\"/>" << std::endl;
if (vec.size()) bin.write((char*)vec.data(),vec.size()*sizeof(T));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
addq $0x210, %rdi # imm = 0x210
callq 0x186c0
movq %rax, (%rsp)
cmpq $0x0, 0x420(%rbx)
je 0xa125a
leaq 0x10(%rbx), %r13
xorl %r15d, %r15d
leaq 0xadf26(%rip), %rbp # 0x14f164
movl $... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
void embree::XMLWriter::store_array_binary<float>(char const*, std::vector<float, std::allocator<float>> const&) | void XMLWriter::store_array_binary(const char* name, const std::vector<T>& vec)
{
std::streampos offset = bin.tellg();
tab(); xml << "<" << name << " ofs=\"" << offset << "\" size=\"" << vec.size() << "\"/>" << std::endl;
if (vec.size()) bin.write((char*)vec.data(),vec.size()*sizeof(T));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
addq $0x210, %rdi # imm = 0x210
callq 0x186c0
movq %rax, (%rsp)
cmpq $0x0, 0x420(%rbx)
je 0xa177c
leaq 0x10(%rbx), %r13
xorl %r15d, %r15d
leaq 0xada04(%rip), %rbp # 0x14f164
movl $... | /embree[P]embree/tutorials/common/scenegraph/xml_writer.cpp |
embree::CoronaLoader::loadObject(embree::Ref<embree::XML> const&) | Ref<SceneGraph::Node> CoronaLoader::loadObject(const Ref<XML>& xml)
{
if (xml->name != "object")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid object node");
if (xml->parm("class") != "file")
THROW_RUNTIME_ERROR(xml->loc.str()+": invalid object class");
const FileName fileName = load<FileNam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
addq $0x30, %rdi
leaq 0xafc67(%rip), %rsi # 0x15875c
callq 0x17290
testl %eax, %eax
jne 0xa8bdc
movq (%r15), %r12
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xa... | /embree[P]embree/tutorials/common/scenegraph/corona_loader.cpp |
embree::Token::Sym(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | static Token Sym(std::string str) { return Token(str,TY_SYMBOL); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1ac76
pxor %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movdqa %xmm0, (%rcx)
pcmpeqd %xmm0, %xmm0
movdqa %xm... | /embree[P]embree/tutorials/common/scenegraph/../../../common/lexers/tokenstream.h |
embree::StdStream::StdStream(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | StdStream (std::istream& cin, const std::string& name = "std::stream")
: cin(cin), lineNumber(1), colNumber(0), charNumber(0), name(std::shared_ptr<std::string>(new std::string(name))) {} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x11e411(%rip), %r13 # 0x1cbac8
movq %r13, (%rdi)
leaq 0x28(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
leaq 0xf(%rsp), %... | /embree[P]embree/tutorials/common/scenegraph/../../../common/lexers/stream.h |
embree::ImageT<embree::Col4<unsigned char>>::ImageT(unsigned long, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ImageT (size_t width = 0, size_t height = 0, const std::string& name = "")
: Image(width,height,name)
{
data = new T[width*height];
memset((void*)data,0,width*height*sizeof(T));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x11d3b5(%rip), %r12 # 0x1cdb88
movq %r12, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq (%rcx), %rsi
movq 0x8(%rcx),... | /embree[P]embree/tutorials/common/image/image.h |
stbi_load | STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp)
{
FILE *f = stbi__fopen(filename, "rb");
unsigned char *result;
if (!f) return stbi__errpuc("can't fopen", "Unable to open file");
result = stbi_load_from_file(f,x,y,comp,req_comp);
fclose(f);
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0xa7054(%rip), %rsi # 0x158057
callq 0x17e00
testq %rax, %rax
je 0xb1034
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0xb105a
movq %rax... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__load_and_postprocess_16bit(stbi__context*, int*, int*, int*, int) | static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
stbi__result_info ri;
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
if (result == NULL)
return NULL;
// it is the responsibility of the loaders to make sure we get e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movl $0x10, (%rsp)
leaq 0x1c(%rsp), %r9
callq 0xb67d2
testq %rax, %rax
je 0xb13a7
movq %rax, %r13
cmpl $0x10, 0x1c(%rsp)
je 0xb13d8
movl (%r15), %eax
movl (%r14), %r12d
movl... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_load_gif_from_memory | STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_mem(&s,buffer,len);
result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
if (stbi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8998, %rsp # imm = 0x8998
movq %r9, %rbx
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, %r12
movq 0x89d0(%rsp), %r15
leaq 0x48(%rsp), %rcx
movq $0x0, 0x10(%rcx)
xorl %eax, %eax
movl %eax, 0x30(%rcx)
movl %eax, 0xb8(%rcx)
movq %rd... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_zlib_decode_malloc_guesssize | STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(initial_size);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer + len;
if (stbi__do_zlib(&a, p, init... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %rdi
callq 0x17fe0
testq %rax, %rax
je 0xb2128
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movslq %r15d, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_zlib_decode_noheader_malloc | STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen)
{
stbi__zbuf a;
char *p = (char *) stbi__malloc(16384);
if (p == NULL) return NULL;
a.zbuffer = (stbi_uc *) buffer;
a.zbuffer_end = (stbi_uc *) buffer+len;
if (stbi__do_zlib(&a, p, 16384, 1, 0)) {
if (outlen... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp # imm = 0x1000
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x4000, %edi # imm = 0x4000
callq 0x17fe0
testq %rax, %rax
je 0xb2c9f
movq %rsp, %rdi
movq %r14, (%rdi)
movslq %ebp, %rcx
addq %r14, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rsi
movl... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_info | STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp)
{
FILE *f = stbi__fopen(filename, "rb");
int result;
if (!f) return stbi__err("can't fopen", "Unable to open file");
result = stbi_info_from_file(f, x, y, comp);
fclose(f);
return result;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0xa52f8(%rip), %rsi # 0x158057
callq 0x17e00
testq %rax, %rax
je 0xb2d8b
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xb2db3
movl %eax, %ebx
movq %r12, %rdi
callq 0x1... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_is_16_bit | STBIDEF int stbi_is_16_bit(char const *filename)
{
FILE *f = stbi__fopen(filename, "rb");
int result;
if (!f) return stbi__err("can't fopen", "Unable to open file");
result = stbi_is_16_bit_from_file(f);
fclose(f);
return result;
} | pushq %rbp
pushq %rbx
pushq %rax
leaq 0xa4f52(%rip), %rsi # 0x158057
callq 0x17e00
testq %rax, %rax
je 0xb3128
movq %rax, %rbx
movq %rax, %rdi
callq 0xb314b
movl %eax, %ebp
movq %rbx, %rdi
callq 0x17b90
movl %ebp, %eax
jmp 0xb3144
movq %fs:0x0, %rax
leaq 0xa7c01(%rip), %rcx # 0x15ad3c
movq %rcx, -0x20(%rax)
xor... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_info_from_callbacks | STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
return stbi__info_main(&s,x,y,comp);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq 0x10(%rdi), %rax
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x8000000001
movq %rax, -0x8(%rcx)
... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_write_bmp | STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_bmp_core(&s, x, y, comp, data);
stbi__end_write_file(&s);
return r;
} else
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x50(%rsp)
leaq 0xa772d(%rip), %... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbiw__zlib_flushf(unsigned char*, unsigned int*, int*) | static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
while (*bitcount >= 8) {
stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
*bitbuffer >>= 8;
*bitcount -= 8;
}
return data;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
cmpl $0x8, (%rdx)
jl 0xb4c46
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xb4c14
movl -0x4(%rax), %ecx
incl %ecx
cmpl -0x8(%rax), %ecx
jl 0xb4c21
movq %r15, %rdi
movl $0x1, %esi
callq 0xb4b84
movb (%... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbi_write_png_to_func | STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
{
int len;
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
if (png == NULL) return 0;
func(context, png, len);
ST... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rsp), %esi
leaq 0xc(%rsp), %r9
movq %rax, %rdi
callq 0xb4c55
testq %rax, %rax
je 0xb5381
movq %rax, %r15
movl 0xc(%rsp), %edx
movq %r14, %rdi
movq %rax, %rsi
callq *%rbx
movq %r15, %rdi
callq 0x17e30
movl $0x1, %... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
embree::storeSTB(embree::Ref<embree::Image> const&, embree::FileName const&) | void storeSTB(const Ref<Image>& img, const FileName& fileName)
{
std::string ext = toLowerCase(fileName.ext());
if (ext != "bmp" && ext != "png" && ext != "jpg") {
THROW_RUNTIME_ERROR("Could not store image")
return;
}
int width = int(img->width);
int height = int(img->height);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xdcdec
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
callq 0xdde18
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb63fa
callq 0x17b20
leaq 0xa25ab(%r... | /embree[P]embree/tutorials/common/image/stb.cpp |
stbi__pic_test(stbi__context*) | static int stbi__pic_test(stbi__context *s)
{
int r = stbi__pic_test_core(s);
stbi__rewind(s);
return r;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa1970(%rip), %rsi # 0x15b00b
callq 0xc14b9
testl %eax, %eax
je 0xb96ed
movl $0x54, %ebp
movq 0xc0(%rbx), %rax
cmpq 0xc8(%rbx), %rax
jb 0xb96ce
cmpl $0x0, 0x30(%rbx)
je 0xb96d8
movq %rbx, %rdi
callq 0xbd4da
movq 0xc0(%rbx), %rax
incq %rax
movq %rax, 0xc0(%rbx)
... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__pnm_test(stbi__context*) | static int stbi__pnm_test(stbi__context *s)
{
char p, t;
p = (char) stbi__get8(s);
t = (char) stbi__get8(s);
if (p != 'P' || (t != '5' && t != '6')) {
stbi__rewind( s );
return 0;
}
return 1;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
cmpq 0xc8(%rdi), %rax
jb 0xbbf8a
cmpl $0x0, 0x30(%rbx)
je 0xbbffa
movq %rbx, %rdi
callq 0xbd4da
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%rbx)
cmpb $0x50, (%rax)
setne %bpl
movq 0xc0(%rbx), %rax
cmpq 0xc8(%rbx), %rax
jb 0xbbfc1
cmp... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__hdr_load(stbi__context*, int*, int*, int*, int, stbi__result_info*) | static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int width, height;
stbi_uc *scanline;
float *hdr_data;
int len;
unsigned char count, value;
int i, j, k, c1,c2, z;
con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp # imm = 0x488
movl %r8d, %r15d
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x80(%rsp), %r12
movq %r12, %rsi
callq 0xc4468
movabsq $0x4e41494441523f23, %rax # imm = 0x4E41494441523F23
xorq (%r12), %rax... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__check_png_header(stbi__context*) | static int stbi__check_png_header(stbi__context *s)
{
static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
int i;
for (i=0; i < 8; ++i)
if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
return 1;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x9d906(%rip), %r15 # 0x15ad34
movq 0xc0(%rbx), %rax
cmpq 0xc8(%rbx), %rax
jb 0xbd453
cmpl $0x0, 0x30(%rbx)
je 0xbd471
movq %rbx, %rdi
callq 0xbd4da
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%rbx)
movb (%rax), %al
cmpb (%r14,%r... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__mad3sizes_valid(int, int, int, int) | static int stbi__mad3sizes_valid(int a, int b, int c, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__addsizes_valid(a*b*c, add);
} | xorl %r9d, %r9d
movl %esi, %eax
orl %edi, %eax
js 0xbfe51
movl %edx, %r8d
testl %esi, %esi
je 0xbfe18
xorl %r9d, %r9d
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %esi
cmpl %edi, %eax
jl 0xbfe51
imull %edi, %esi
movl %esi, %eax
orl %r8d, %eax
movl $0x0, %r9d
js 0xbfe51
testl %r8d, %r8d
je 0xbfe3... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__high_bit(unsigned int) | static int stbi__high_bit(unsigned int z)
{
int n=0;
if (z == 0) return -1;
if (z >= 0x10000) { n += 16; z >>= 16; }
if (z >= 0x00100) { n += 8; z >>= 8; }
if (z >= 0x00010) { n += 4; z >>= 4; }
if (z >= 0x00004) { n += 2; z >>= 2; }
if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
return n;
} | testl %edi, %edi
je 0xc03d4
movl %edi, %eax
shrl $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setae %cl
cmovbl %edi, %eax
shll $0x4, %ecx
leal 0x8(%rcx), %edx
movl %eax, %esi
shrl $0x8, %esi
cmpl $0x100, %eax # imm = 0x100
cmovbl %eax, %esi
cmovbl %ecx, %edx
leal 0x4(%rdx), %ecx
m... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__gif_header(stbi__context*, stbi__gif*, int*, int) | static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info)
{
stbi_uc version;
if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8')
return stbi__err("not GIF", "Corrupt GIF");
version = stbi__get8(s);
if (version != '7' && version !... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc0(%rdi), %rax
cmpq 0xc8(%rdi), %rax
jb 0xc0e5c
cmpl $0x0, 0x30(%r14)
je 0xc10bb
movq %r14, %rdi
callq 0xbd4da
movq 0xc0(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%r... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__pic_is4(stbi__context*, char const*) | static int stbi__pic_is4(stbi__context *s,const char *str)
{
int i;
for (i=0; i<4; ++i)
if (stbi__get8(s) != (stbi_uc)str[i])
return 0;
return 1;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0xc0(%r14), %rax
cmpq 0xc8(%r14), %rax
jb 0xc14ed
cmpl $0x0, 0x30(%r14)
je 0xc150b
movq %r14, %rdi
callq 0xbd4da
movq 0xc0(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%r14)
movb (%rax), %al
cmpb (%rbx,%r15), %al
jne 0xc150f
inc... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__YCbCr_to_RGB_row(unsigned char*, unsigned char const*, unsigned char const*, unsigned char const*, int, int) | static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step)
{
int i;
for (i=0; i < count; ++i) {
int y_fixed = (y[i] << 20) + (1<<19); // rounding
int r,g,b;
int cr = pcr[i] - 128;
int cb = pcb[i] - 128;
r = y_fixed ... | testl %r8d, %r8d
jle 0xc1c77
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %r9d, %rax
movl %r8d, %r8d
addq $0x3, %rdi
xorl %r9d, %r9d
xorl %r10d, %r10d
movl $0xff, %ebp
movzbl (%rsi,%r10), %ebx
shll $0x14, %ebx
movzbl (%rcx,%r10), %r14d
addl $-0x80, %r14d
imull $0x166f00, %r14d, %r11d # imm = 0x166F00
a... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// resample with nearest-neighbor
int i,j;
STBI_NOTUSED(in_far);
for (i=0; i < w; ++i)
for (j=0; j < hs; ++j)
out[i*hs+j] = in_near[i];
return out;
} | movq %rdi, %rax
testl %ecx, %ecx
jle 0xc382b
movl %r8d, %edx
movl %ecx, %ecx
xorl %edi, %edi
movq %rax, %r9
testl %r8d, %r8d
jle 0xc3820
xorl %r10d, %r10d
movb (%rsi,%rdi), %r11b
movb %r11b, (%r9,%r10)
incq %r10
cmpq %r10, %rdx
jne 0xc3810
incq %rdi
addq %rdx, %r9
cmpq %rcx, %rdi
jne 0xc3808
retq
| /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__zbuild_huffman(stbi__zhuffman*, unsigned char const*, int) | static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num)
{
int i,k=0;
int code, next_code[16], sizes[17];
// DEFLATE spec for generating codes
memset(sizes, 0, sizeof(sizes));
memset(z->fast, 0, sizeof(z->fast));
for (i=0; i < num; ++i)
++sizes[sizelist[i]];
sizes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
pxor %xmm0, %xmm0
movdqa %xmm0, 0x50(%rsp)
movdqa %xmm0, 0x40(%rsp)
movdqa %xmm0, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
movl $0x0, 0x60(%rsp)
movl $0x400, %edx # imm = 0x400
xorl %... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbiw__jpg_processDU(stbi__write_context*, int*, int*, float*, int, float*, int, unsigned short const (*) [2], unsigned short const (*) [2]) | static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
const unsigned short M16zeroes[2] = { HTAC[0xF0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r9, 0x20(%rsp)
movq %rcx, %r13
movq %rdx, 0x28(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x1a0(%rsp), %rcx
movl (%rcx), %eax
movl %eax, 0x4c(%rsp)
movl 0x3c0(%rcx), %eax
movl %eax, 0x48(%rsp)
m... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
LoadEXRImageFromFile | int LoadEXRImageFromFile(EXRImage *exr_image, const EXRHeader *exr_header,
const char *filename, const char **err) {
if (exr_image == NULL) {
tinyexr::SetErrorMessage("Invalid argument for LoadEXRImageFromFile", err);
return TINYEXR_ERROR_INVALID_ARGUMENT;
}
FILE *fp = NULL;
#ifd... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
testq %rdi, %rdi
je 0xc776e
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
leaq 0x90988(%rip), %rsi # 0x158057
movq %rdx, %rdi
callq 0x17e00
testq %rax, %rax
je 0xc77ba
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi... | /embree[P]embree/tutorials/common/image/tinyexr.h |
SaveEXRMultipartImageToMemory | size_t SaveEXRMultipartImageToMemory(const EXRImage* exr_images,
const EXRHeader** exr_headers,
unsigned int num_parts,
unsigned char** memory_out, const char** err) {
if (exr_images == NULL || exr_headers =... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %r8b
andb %al, %r8b
cmpl $0x2, %edx
setae %al
andb %r8b, %al
testq %rcx, %rcx
setne %r8b
testb %r8b, %al
jne 0xcbc4b
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8fabd(%rip), %rsi # 0x15b6cc
leaq 0x8fae4(%... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::DecompressZip(unsigned char*, unsigned long*, unsigned char const*, unsigned long) | static bool DecompressZip(unsigned char *dst,
unsigned long *uncompressed_size /* inout */,
const unsigned char *src, unsigned long src_size) {
if ((*uncompressed_size) == src_size) {
// Data is not compressed(Issue 40).
memcpy(dst, src, src_size);
retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
cmpq %rcx, %rsi
jne 0xcd2a3
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x178f0
movb $0x1, %bpl
jmp 0xcd365
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp),... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::PrecalculateTileInfo(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, TEXRHeader const*) | static void PrecalculateTileInfo(std::vector<int>& num_x_tiles,
std::vector<int>& num_y_tiles,
const EXRHeader* exr_header) {
int min_x = exr_header->data_window.min_x;
int max_x = exr_header->data_window.max_x;
int min_y = exr_header->data_window.min_y;
int max_y = exr_header->data_window.max_y;
int num... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl 0x8(%rdx), %ecx
movl 0xc(%rdx), %ebx
movl 0x10(%rdx), %r12d
movl 0x14(%rdx), %ebp
movl 0x44(%rdx), %r15d
cmpl $0x2, %r15d
movl %ecx, (%rsp)
je 0xce6b2
cmpl $0x1, %r15d
je 0x... | /embree[P]embree/tutorials/common/image/tinyexr.h |
LoadEXRMultipartImageFromFile | int LoadEXRMultipartImageFromFile(EXRImage *exr_images,
const EXRHeader **exr_headers,
unsigned int num_parts, const char *filename,
const char **err) {
if (exr_images == NULL || exr_headers == NULL || num_parts == 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r13
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testl %edx, %edx
setne %al
testb %al, %cl
jne 0xcf632
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8c427(%rip), %rsi # 0x15ba1d... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::EncodePixelData(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const* const*, int, int, int, int, int, int, int, unsigned long, std::vector<tinyexr::TChannelInfo, std::allocator<tinyexr::TChannelInfo>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&, std::__c... | static bool EncodePixelData(/* out */ std::vector<unsigned char>& out_data,
const unsigned char* const* images,
int compression_type,
int /*line_order*/,
int width, // for tiled : til... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %r9d, 0x8(%rsp)
movl %r8d, (%rsp)
movl %ecx, %ebp
movl %edx, 0xb0(%rsp)
movq %rsi, %r12
movq %rdi, 0xc0(%rsp)
movslq 0x180(%rsp), %rsi
movq 0x1a0(%rsp), %r14
movq 0x190(%rsp), %rbx
movq 0x188(%rsp), %r13
mo... | /embree[P]embree/tutorials/common/image/tinyexr.h |
embree::alignedUSMFree(void*) | void alignedUSMFree(void* ptr)
{
#if defined(EMBREE_SYCL_SUPPORT)
if (tls_context)
return alignedSYCLFree(tls_context,ptr);
else
#endif
return alignedFree(ptr);
} | jmp 0xdc3f5
nop
| /embree[P]embree/tutorials/common/alloc/alloc.cpp |
embree::StringStream::next[abi:cxx11]() | std::string StringStream::next()
{
/* skip separators */
while (cin->peek() != EOF) {
if (endl != "" && cin->peek() == '\n') { cin->drop(); return endl; }
if (multiLine && cin->peek() == '\\') {
cin->drop();
if (cin->peek() == '\n') { cin->drop(); continue; }
cin->unget();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x1c43c
cmpl $-0x1, (%rax)
je 0xd8a53
leaq 0x248(%r14), %r15
leaq 0x7dc5f(%rip), %r12 # 0x15661e
movq %r15, %rdi
movq %r12, %rsi
callq 0x17290
testl %eax, %eax
je 0xd89e0
movq 0x40(%r1... | /embree[P]embree/common/lexers/stringstream.cpp |
embree::TokenStream::TokenStream(embree::Ref<embree::Stream<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std... | TokenStream::TokenStream(const Ref<Stream<int> >& cin, //< stream to read from
const std::string& alpha, //< valid characters for identifiers
const std::string& seps, //< characters that act as separators
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0xf6291(%rip), %rcx # 0x1cf358
movq %rcx, (%rdi)
leaq 0x28(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
mov... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::tryString(embree::Token&, embree::ParseLocation const&) | bool TokenStream::tryString(Token& token, const ParseLocation& loc)
{
std::string str;
if (cin->peek() != '\"') return false;
cin->drop();
while (cin->peek() != '\"') {
const int c = cin->get();
if (!isStringChar(c)) THROW_RUNTIME_ERROR("invalid string character "+std::string(1,c)+" at "+l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x40(%rdi), %rdi
callq 0x1c43c
movl (%rax), %r13d
cmpl $0x22, %r13d
jne 0... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::PointLight_eval(embree::Light const*, embree::DifferentialGeometry const&, embree::Vec3fa const&) | SYCL_EXTERNAL Light_EvalRes PointLight_eval(const Light* super,
const DifferentialGeometry& dg,
const Vec3fa& dir)
{
const PointLight* self = (PointLight*)super;
Light_EvalRes res;
res.value = Vec... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movss 0x7c475(%rip), %xmm0 # 0x157530
movlps %xmm0, 0x10(%rdi)
movss 0x30(%rsi), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jbe 0xdb2af
movq %rsi, %r14
movaps 0x10(%rsi), %xmm2
subps 0x20(%rdx), %xmm2
movaps (%rcx), %xm... | /embree[P]embree/tutorials/common/lights/point_light.cpp |
embree::getCPUVendor[abi:cxx11]() | std::string getCPUVendor()
{
#if defined(__X86_ASM__)
int cpuinfo[4];
__cpuid (cpuinfo, 0);
int name[4];
name[0] = cpuinfo[1];
name[1] = cpuinfo[3];
name[2] = cpuinfo[2];
name[3] = 0;
return (char*)name;
#elif defined(__ARM_NEON)
return "ARM";
#else
return "Unknown";
#endif
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
xorl %eax, %eax
cpuid
movq %rsp, %r15
movl %ebx, (%r15)
movl %edx, 0x4(%r15)
movl %ecx, 0x8(%r15)
movl $0x0, 0xc(%r15)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r15, %rdi
callq 0x174d0
leaq (%rsp,%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::stringOfCPUModel[abi:cxx11](embree::CPU) | std::string stringOfCPUModel(CPU model)
{
switch (model) {
case CPU::XEON_ICE_LAKE : return "Xeon Ice Lake";
case CPU::CORE_ICE_LAKE : return "Core Ice Lake";
case CPU::CORE_TIGER_LAKE : return "Core Tiger Lake";
case CPU::CORE_COMET_LAKE : return "Core Comet La... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x15, %esi
ja 0xdb786
movl %esi, %eax
leaq 0x8109d(%rip), %rcx # 0x15c6a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x81166(%rip), %rsi # 0x15c779
leaq 0x8116c(%rip), %rdx # 0x15c786
jmp 0xdb7a4
leaq 0x81252(%rip), %rs... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::getCPUFeatures() | int getCPUFeatures()
{
#if defined(__X86_ASM__)
/* cache CPU features access */
static int cpu_features = 0;
if (cpu_features)
return cpu_features;
/* get number of CPUID leaves */
int cpuid_leaf0[4];
__cpuid(cpuid_leaf0, 0x00000000);
unsigned nIds = cpuid_leaf0[EAX];
/* ge... | movl 0xf6791(%rip), %eax # 0x1d1f50
testl %eax, %eax
je 0xdb7c4
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
xorl %eax, %eax
cpuid
movl %eax, %edi
movl $0x80000000, %eax # imm = 0x80000000
cpuid
movl %eax, %esi
movl $0x0, %r14d
movl $0x0, %r15d
testl %edi, ... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::getExecutableFileName[abi:cxx11]() | std::string getExecutableFileName()
{
std::string pid = "/proc/" + toString(getpid()) + "/exe";
char buf[4096];
memset(buf,0,sizeof(buf));
if (readlink(pid.c_str(), buf, sizeof(buf)-1) == -1)
return std::string();
return std::string(buf);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1048, %rsp # imm = 0x1048
movq %rdi, %rbx
callq 0x18240
movslq %eax, %r15
movq %r15, %r14
negq %r14
cmovsq %r15, %r14
movl $0x1, %r12d
cmpq $0xa, %r14
jb 0xdbfcf
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D638865... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::os_malloc(unsigned long, bool&) | void* os_malloc(size_t bytes, bool& hugepages)
{
if (bytes == 0) {
hugepages = false;
return nullptr;
}
/* try direct huge page allocation first */
if (isHugePageCandidate(bytes))
{
#if defined(__MACOSX__)
void* ptr = mmap(0, bytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_AN... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0xdc9cf
movq %rdi, %r14
cmpb $0x1, 0xf5628(%rip) # 0x1d1f68
jne 0xdc994
leaq 0x1fffff(%r14), %rax
movabsq $0x7fffffffffe00000, %rcx # imm = 0x7FFFFFFFFFE00000
andq %rax, %rcx
subq %r14, %rcx
movq %rcx, %rax
shlq $0x6, %rax
leaq (%rax,%rcx,2), %rax... | /embree[P]embree/common/sys/alloc.cpp |
embree::FileName::base[abi:cxx11]() const | std::string FileName::base() const {
size_t pos = filename.find_last_of(path_sep);
if (pos == std::string::npos) return filename;
return filename.substr(pos+1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x18970
cmpq $-0x1, %rax
je 0xdcdc8
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x17c10
jmp 0xdcde1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::dropExt() const | FileName FileName::dropExt() const {
size_t pos = filename.find_last_of('.');
if (pos == std::string::npos) return filename;
return filename.substr(0,pos);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x18970
cmpq $-0x1, %rax
je 0xdceaa
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x17c10
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdcbce
leaq 0... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::operator+(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | FileName FileName::operator +( const std::string& other ) const {
return operator+(FileName(other));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xdcbce
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xdd0fc
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdd276
callq 0x17b20
movq %rbx, %rax
addq $0x20, ... | /embree[P]embree/common/sys/filename.cpp |
embree::threadStartup(embree::ThreadStartupData*) | static void* threadStartup(ThreadStartupData* parg)
{
_mm_setcsr(_mm_getcsr() | /*FTZ:*/ (1<<15) | /*DAZ:*/ (1<<6));
/*! Mac OS X does not support setting affinity at thread creation time */
#if defined(__MACOSX__)
if (parg->affinity >= 0)
setAffinity(parg->affinity);
#endif
parg->f(parg->arg);... | pushq %rbx
subq $0x10, %rsp
stmxcsr 0xc(%rsp)
movl $0x8040, %eax # imm = 0x8040
orl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
ldmxcsr 0x8(%rsp)
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq *(%rbx)
movq %rbx, %rdi
callq 0x17b20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| /embree[P]embree/common/sys/thread.cpp |
embree::string_to_Vec2f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Vec2f string_to_Vec2f ( std::string str )
{
size_t next = 0;
const float x = std::stof(str,&next); str = str.substr(next+1);
const float y = std::stof(str,&next);
return Vec2f(x,y);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
callq 0x17090
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x18000
movq (%r13), %rdx
subq %r12, %rdx
je 0xddfb8
movl (%rb... | /embree[P]embree/common/sys/estring.cpp |
embree::BarrierSys::wait() | void BarrierSys::wait() {
((BarrierSysImplementation*) opaque)->wait();
} | pushq %rbx
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0xde4b2
incq 0x10(%rbx)
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jne 0xde64b
movq $0x0, 0x10(%rbx)
leaq 0x8(%rbx), %rdi
callq 0xdee22
jmp 0xde657
leaq 0x8(%rbx), %rdi
movq %rbx, %rsi
callq 0xdedc2
movq %rbx, %rdi
popq %rbx
jmp 0xde520
| /embree[P]embree/common/sys/barrier.cpp |
ImGuiStyle::ScaleAllSizes(float) | IM_MSVC_RUNTIME_CHECKS_OFF
static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x * rhs, lhs.y * rhs); } | movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1 # xmm1 = xmm1[0,0],xmm0[0,0]
movsd 0x8(%rdi), %xmm4
movsd 0x18(%rdi), %xmm5
movsd 0x3c(%rdi), %xmm3
movsd 0x4c(%rdi), %xmm2
mulps %xmm1, %xmm4
cvttps2dq %xmm4, %xmm4
cvtdq2ps %xmm4, %xmm4
movlps %xmm4, 0x8(%rdi)
movss 0x10(%rdi), %xmm4
mulss %xmm0, %xmm4
cvttps2dq %xmm... | /embree[P]embree/tutorials/common/imgui/imgui_internal.h |
ImGuiIO::ClearInputKeys() | void ImGuiIO::ClearInputKeys()
{
#ifndef IMGUI_DISABLE_OBSOLETE_KEYIO
memset(KeysDown, 0, sizeof(KeysDown));
#endif
for (int n = 0; n < IM_ARRAYSIZE(KeysData); n++)
{
KeysData[n].Down = false;
KeysData[n].DownDuration = -1.0f;
KeysData[n].DownDurationPrev = -1.0f;
... | pushq %rbx
movq %rdi, %rbx
addq $0xb28, %rdi # imm = 0xB28
movl $0x28c, %edx # imm = 0x28C
xorl %esi, %esi
callq 0x17600
movl $0xe18, %eax # imm = 0xE18
movsd 0x7bb4c(%rip), %xmm0 # 0x15b3d0
movb $0x0, -0x4(%rbx,%rax)
movsd %xmm0, (%rbx,%rax)
addq $0x10, %rax
cmpq $0x36d8, %rax ... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImFormatString(char*, unsigned long, char const*, ...) | int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
#ifdef IMGUI_USE_STB_SPRINTF
int w = stbsp_vsnprintf(buf, (int)buf_size, fmt, args);
#else
int w = vsnprintf(buf, buf_size, fmt, args);
#endif
va_end(args);
if (buf == NULL)
return w... | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r10
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0xe0ef7
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%r... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImTextStrToUtf8(char*, int, unsigned short const*, unsigned short const*) | int ImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_text, const ImWchar* in_text_end)
{
char* buf_p = out_buf;
const char* buf_end = out_buf + out_buf_size;
while (buf_p < buf_end - 1 && (!in_text_end || in_text < in_text_end) && *in_text)
{
unsigned int c = (unsigned int)(*in... | movslq %esi, %rsi
leaq (%rdi,%rsi), %r8
decq %r8
movq %rdi, %rax
cmpq %rdi, %r8
jbe 0xe15ae
addq %rdi, %rsi
movq %rdi, %rax
testq %rcx, %rcx
sete %r9b
cmpq %rcx, %rdx
setb %r10b
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0xe15ae
movzwl (%rdx), %r9d
testw %r9w, %r9w
je 0xe15ae
cmpw $0x7f, %r9w
ja 0xe1525
movb %r9b, (%rax)
inc... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImAlphaBlendColors(unsigned int, unsigned int) | IMGUI_API ImU32 ImAlphaBlendColors(ImU32 col_a, ImU32 col_b)
{
float t = ((col_b >> IM_COL32_A_SHIFT) & 0xFF) / 255.f;
int r = ImLerp((int)(col_a >> IM_COL32_R_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_R_SHIFT) & 0xFF, t);
int g = ImLerp((int)(col_a >> IM_COL32_G_SHIFT) & 0xFF, (int)(col_b >> IM_COL32_G_SHIFT)... | movl %esi, %eax
shrl $0x18, %eax
cvtsi2ss %eax, %xmm0
movl $0xff, %eax
movl %edi, %ecx
andl %eax, %ecx
movl %esi, %edx
andl %eax, %edx
cvtsi2ss %ecx, %xmm1
subl %ecx, %edx
cvtsi2ss %edx, %xmm2
divss 0x74b01(%rip), %xmm0 # 0x15613c
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %ecx
movl %edi, %edx
shrl $0x8,... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGuiStorage::GetVoidPtr(unsigned int) const | static ImGuiStorage::ImGuiStoragePair* LowerBound(ImVector<ImGuiStorage::ImGuiStoragePair>& data, ImGuiID key)
{
ImGuiStorage::ImGuiStoragePair* first = data.Data;
ImGuiStorage::ImGuiStoragePair* last = data.Data + data.Size;
size_t count = (size_t)(last - first);
while (count > 0)
{
size_t ... | movq 0x8(%rdi), %rcx
movslq (%rdi), %rdx
movq %rcx, %rax
testq %rdx, %rdx
je 0xe1a7d
movq %rcx, %rax
movq %rdx, %r8
movq %rdx, %rdi
shrq %rdi
movq %rdi, %r9
shlq $0x4, %r9
cmpl %esi, (%rax,%r9)
jae 0xe1a75
notq %rdi
addq %r8, %rdi
addq %r9, %rax
addq $0x10, %rax
movq %rdi, %r8
testq %rdi, %rdi
jne 0xe1a58
shlq $0x4, %r... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::PushStyleVar(int, float) | static const ImGuiStyleVarInfo* GetStyleVarInfo(ImGuiStyleVar idx)
{
IM_ASSERT(idx >= 0 && idx < ImGuiStyleVar_COUNT);
IM_ASSERT(IM_ARRAYSIZE(GStyleVarInfo) == ImGuiStyleVar_COUNT);
return &GStyleVarInfo[idx];
} | movslq %edi, %rax
leaq (%rax,%rax,2), %rax
leaq 0x799f7(%rip), %rcx # 0x15d7b0
cmpl $0x8, (%rcx,%rax,4)
jne 0xe3f02
leaq (%rcx,%rax,4), %rax
cmpl $0x1, 0x4(%rax)
jne 0xe3f02
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0xee24a(%rip), %r15 # 0x1d2030
movl 0x8(%rax)... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::FindRenderedTextEnd(char const*, char const*) | const char* ImGui::FindRenderedTextEnd(const char* text, const char* text_end)
{
const char* text_display_end = text;
if (!text_end)
text_end = (const char*)-1;
while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
tex... | movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x1, %rsi
sbbq %rcx, %rcx
orq %rsi, %rcx
cmpq %rdi, %rcx
jbe 0xe414a
movzbl (%rax), %edx
cmpl $0x23, %edx
je 0xe4139
testl %edx, %edx
jne 0xe413f
jmp 0xe414a
cmpb $0x23, 0x1(%rax)
je 0xe414a
incq %rax
cmpq %rcx, %rax
jne 0xe412b
movq %rcx, %rax
retq
| /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::RenderTextClippedEx(ImDrawList*, ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*) | void ImGui::RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_display_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
// Perform CPU side clipping for single clipped element to avoid using scissor state
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq 0x78(%rsp), %rbp
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
testq %r9, %r9
je 0xe4556
movsd (%r9), %xmm0
jmp 0xe45ad
movq 0xedad3(%rip), %rax # 0x1d2030
... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::RenderTextClipped(ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*) | void ImGui::RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
// Hide anything after a '##' string
const char* text_display_end = FindRenderedTextEnd(text, text_end);
const... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r9
movq %rdx, %rbx
movq %rsi, %rdx
xorl %esi, %esi
cmpq $0x1, %rcx
sbbq %rsi, %rsi
movq %rdi, %r14
orq %rcx, %rsi
movq %rbx, %r15
cmpq %rbx, %rsi
jbe 0xe4835
movq %rbx, %r15
movzbl (%r15), %ecx
cmpl $0x23, %ecx
je 0xe4823
testl %ecx, %ecx
... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::RenderNavHighlight(ImRect const&, unsigned int, int) | void ImGui::RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags)
{
ImGuiContext& g = *GImGui;
if (id != g.NavId)
return;
if (g.NavDisableHighlight && !(flags & ImGuiNavHighlightFlags_AlwaysDraw))
return;
ImGuiWindow* window = g.CurrentWindow;
if (window->DC.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0xed0e9(%rip), %rax # 0x1d2030
cmpl %esi, 0x4870(%rax)
jne 0xe5113
movl %edx, %ebx
testb $0x4, %bl
jne 0xe4f67
cmpb $0x0, 0x48aa(%rax)
jne 0xe5113
movq 0x3ea0(%rax), %rbp
cmpb $0x0, 0x140(%rbp)
jne 0xe5113
xorps %xmm0, %xmm0
mov... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGuiWindow::~ImGuiWindow() | ImGuiWindow::~ImGuiWindow()
{
IM_ASSERT(DrawList == &DrawListInst);
IM_DELETE(Name);
ColumnsStorage.clear_destruct();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xe574d
movq 0xec8fb(%rip), %rax # 0x1d2030
testq %rax, %rax
je 0xe5740
decl 0xf4(%rax)
movq 0xec8f9(%rip), %rsi # 0x1d2040
callq *0xeb94b(%rip) # 0x1d1098
leaq 0x260(%rbx), %rdi
callq 0x101214
leaq 0x280(%rbx), %rdi
callq 0x100f96
movq 0... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGuiWindow::GetID(int) | ImGuiID ImGuiWindow::GetID(int n)
{
ImGuiID seed = IDStack.back();
ImGuiID id = ImHashData(&n, sizeof(n), seed);
ImGuiContext& g = *GImGui;
if (g.DebugHookIdInfo == id)
ImGui::DebugHookIdInfo(id, ImGuiDataType_S32, (void*)(intptr_t)n, NULL);
return id;
} | pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movq 0xd8(%rdi), %rax
movslq 0xd0(%rdi), %rcx
movl -0x4(%rax,%rcx,4), %ebx
notl %ebx
xorl %eax, %eax
leaq 0x77556(%rip), %rcx # 0x15d100
movzbl %bl, %edx
shrl $0x8, %ebx
movzbl 0xc(%rsp,%rax), %edi
xorl %edx, %edi
xorl (%rcx,%rdi,4), %ebx
incq %rax
cmpq $0x4, %rax
jn... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::SetActiveID(unsigned int, ImGuiWindow*) | void ImGui::SetActiveID(ImGuiID id, ImGuiWindow* window)
{
ImGuiContext& g = *GImGui;
// While most behaved code would make an effort to not steal active id during window move/drag operations,
// we at least need to be resilient to it. Cancelling the move is rather aggressive and users of 'master' branch
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movq 0xec0e3(%rip), %r15 # 0x1d2030
movq 0x3eb8(%r15), %rax
testq %rax, %rax
je 0xe5f88
movl 0x3eec(%r15), %ecx
cmpl 0x5c(%rax), %ecx
jne 0xe5f88
testb $0x1, 0x5c2c(%r15)
je 0xe5f7d
leaq 0x77f01(%rip), %rdi # 0x15de77
xorl %eax, %eax
callq 0xe2da5... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::CalcWrapWidthForPos(ImVec2 const&, float) | float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
if (wrap_pos_x < 0.0f)
return 0.0f;
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (wrap_pos_x == 0.0f)
{
// We could decide to setup a default wrapping max point for auto-resizing windows,... | xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0xe6632
movq 0xeba35(%rip), %rax # 0x1d2030
movq 0x3ea0(%rax), %rax
ucomiss %xmm1, %xmm0
jne 0xe6613
jp 0xe6613
movss 0x200(%rax), %xmm0
jmp 0xe6623
jbe 0xe6623
movss 0x18(%rax), %xmm1
subss 0x64(%rax), %xmm1
addss %xmm1, %xmm0
subss (%rdi), %xmm0
maxss 0x69ad1(%rip), %xmm... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.