name string | code string | asm string | file string |
|---|---|---|---|
stbi__de_iphone(stbi__png*) | static void stbi__de_iphone(stbi__png *z)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
if (s->img_out_n == 3) { // convert bgr to rgb
for (i=0; i < pixel_count; ++i) {
stbi_uc t = p[0];
p[0] = p[2];
p[2] = t;
p... | pushq %rax
movq (%rdi), %rsi
movq 0x18(%rdi), %rcx
movl 0x4(%rsi), %eax
movl 0xc(%rsi), %edx
imull (%rsi), %eax
cmpl $0x4, %edx
je 0x352ad
cmpl $0x3, %edx
jne 0x35361
testl %eax, %eax
je 0x3535f
movb (%rcx), %dl
movb 0x2(%rcx), %sil
movb %sil, (%rcx)
movb %dl, 0x2(%rcx)
addq $0x3, %rcx
decl %eax
jne 0x35294
jmp 0x3535f... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__bmp_parse_header(stbi__context*, stbi__bmp_data*) | static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info)
{
int hsz;
if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP");
stbi__get32le(s); // discard filesize
stbi__get16le(s); // discard reserved
stbi__get16le(s); // discard reserved
info... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb8(%rdi), %rax
cmpq 0xc0(%rdi), %rax
jb 0x361ab
cmpl $0x0, 0x30(%rbx)
je 0x3631a
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %r15
movl 0x34(%rbx), %edx
movq %r15, %rsi
callq *0x10(%rbx)
testl %eax, %eax
je 0x3... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__out_gif_code(stbi__gif*, unsigned short) | static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code)
{
stbi_uc *p, *c;
// recurse to decode the prefixes, since the linked-list is backwards,
// and working backwards through an interleaved image would be nasty
if (g->codes[code].prefix >= 0)
stbi__out_gif_code(g, g->codes[code].prefix);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %r14d
movzwl 0x830(%rdi,%r14,4), %eax
testw %ax, %ax
js 0x36d2b
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x36d08
movslq 0x4858(%rbx), %rcx
cmpl 0x4850(%rbx), %ecx
jge 0x36df2
movq 0x4830(%rbx), %rax
movzbl 0x833(%rbx,%r14,4), %edx
cmpb $0x0, 0x3(%rax,%rdx,4)
jns... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__readval(stbi__context*, int, unsigned char*) | static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest)
{
int mask=0x80, i;
for (i=0; i<4; ++i, mask>>=1) {
if (channel & mask) {
if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short");
dest[i]=stbi__get8(s);
}
}
return dest;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x38(%rdi), %r15
leaq 0x39(%rdi), %rax
movq %rax, (%rsp)
movl $0x80, %r13d
xorl %r12d, %r12d
testl %ebp, %r13d
je 0x36f89
cmpq $0x0, 0x10(%r14)
je 0x36efb
movq 0x28(%r14), %rdi
callq *0x20(%... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__pnm_getinteger(stbi__context*, char*) | static int stbi__pnm_getinteger(stbi__context *s, char *c)
{
int value = 0;
while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) {
value = value*10 + (*c - '0');
*c = (char) stbi__get8(s);
}
return value;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %r15
leaq 0x39(%rdi), %r13
xorl %r12d, %r12d
cmpq $0x0, 0x10(%r14)
je 0x37431
movq 0x28(%r14), %rdi
callq *0x20(%r14)
testl %eax, %eax
je 0x37445
cmpl $0x0, 0x30(%r14)
je 0x374d5
movq 0xb8(%r14)... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__hdr_gettoken(stbi__context*, char*) | static char *stbi__hdr_gettoken(stbi__context *z, char *buffer)
{
int len=0;
char c = '\0';
c = (char) stbi__get8(z);
while (!stbi__at_eof(z) && c != '\n') {
buffer[len++] = c;
if (len == STBI__HDR_BUFLEN-1) {
// flush to end of line
while (!stbi__at_eof(z) && stbi__get8(z) !... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb8(%rdi), %rax
cmpq 0xc0(%rdi), %rax
jb 0x37565
cmpl $0x0, 0x30(%r14)
je 0x3753b
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %r15
movl 0x34(%r14), %edx
movq %r15, %rsi
callq *0x10(%r14)
testl %eax, %eax
je 0x3... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__hdr_convert(float*, unsigned char*, int) | static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp)
{
if ( input[3] != 0 ) {
float f1;
// Exponent
f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8));
if (req_comp <= 2)
output[0] = (input[0] + input[1] + input[2]) * f1 / 3;
else {
output[0] = i... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
movzbl 0x3(%rsi), %edi
testl %edi, %edi
je 0x377b2
movq %rsi, %r15
addl $0xffffff78, %edi # imm = 0xFFFFFF78
movss 0x9fc7d(%rip), %xmm0 # 0xd73fc
callq 0xcc70
movzbl (%r15), %eax
cmpl $0x2, %r14d
jg 0x377de
movzbl 0x1(%r15), %ecx
addl %eax, %ecx... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_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 %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x0, 0x40(%rsp)
movl $0x400, %edx # imm = 0x400
xorl %esi, %esi
call... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__fill_bits(stbi__zbuf*) | static void stbi__fill_bits(stbi__zbuf *z)
{
do {
STBI_ASSERT(z->code_buffer < (1U << z->num_bits));
z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits;
z->num_bits += 8;
} while (z->num_bits <= 24);
} | pushq %rax
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %eax
movl %eax, %edx
shrl %cl, %edx
testl %edx, %edx
jne 0x37a7c
movq (%rdi), %rsi
xorl %edx, %edx
cmpq 0x8(%rdi), %rsi
jae 0x37a66
leaq 0x1(%rsi), %rdx
movq %rdx, (%rdi)
movzbl (%rsi), %edx
shll %cl, %edx
orl %edx, %eax
movl %eax, 0x14(%rdi)
leal 0x8(%rcx), %edx
movl %... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__psd_info(stbi__context*, int*, int*, int*) | static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp)
{
int channelCount, dummy;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (stbi__get32be(s) != 0x38425053) {
stbi__rewind( s );
return 0;
}
if (stbi__get16be(s) != 1) {
stbi__rewind( s ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x327c6
movl %eax, %ebp
shll $0x10, %ebp
movq %rbx, %rdi
callq 0x327c6
orl %ebp, %eax
cmpl $0x38425053, %eax # imm = 0x38425053
jne 0x37cde
movq %rbx, %rdi
callq 0x327c6
cmpl $0x1, %eax
jne... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__pic_info(stbi__context*, int*, int*, int*) | static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp)
{
int act_comp=0,num_packets=0,chained,dummy;
stbi__pic_packet packets[10];
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) {
stbi__rewind(s);
return 0;
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xa4bb4(%rip), %rsi # 0xdc8cc
callq 0x36dfa
testl %eax, %eax
je 0x37dd8
cmpq $0x0, 0x10(%r14)
je 0x37d5b
movq 0xc0(%r14), %rcx
movl 0xb8(%r14), %edx
movl %ecx, %eax... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__hdr_info(stbi__context*, int*, int*, int*) | static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp)
{
char buffer[STBI__HDR_BUFLEN];
char *token;
int valid = 0;
int dummy;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
if (stbi__hdr_test(s) == 0) {
stbi__rewind( s );
return 0;
}
for... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x25258
testl %eax, %eax
je 0x38220
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x374e7
cmpb $0x0, (%r13)
je 0x3821c
movq %rb... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbi__tga_info(stbi__context*, int*, int*, int*) | static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp)
{
int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp;
int sz, tga_colormap_type;
stbi__get8(s); // discard Offset
tga_colormap_type = stbi__get8(s); // colormap type
if( tga_colorma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0xb8(%rdi), %rax
cmpq 0xc0(%rdi), %rax
jb 0x382c9
cmpl $0x0, 0x30(%r14)
je 0x382d3
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %r13
movl 0x34(%r14), %edx
movq %r13, %rsi
cal... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image.h |
stbiw__outfile(stbi__write_context*, int, int, int, int, int, int, void*, int, int, char const*, ...) | static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...)
{
if (y < 0 || x < 0) {
return 0;
} else {
va_list v;
va_start(v, fmt);
stbiw__writefv(s, fmt, v);
va_end(v);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
testb %al, %al
je 0x3881b
movaps %xmm0, 0x80(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm3, 0xb0(%rsp)
movaps %xmm4, 0xc0(%rsp)
movaps %xmm5, 0xd0(%rsp)
movaps %xmm6, 0xe0(%rsp)
movaps %xm... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image_write.h |
stbiw__write_pixel(stbi__write_context*, int, int, int, int, unsigned char*) | static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
{
unsigned char bg[3] = { 255, 0, 255}, px[3];
int k;
if (write_alpha < 0)
s->func(s->context, &d[comp - 1], 1);
switch (comp) {
case 2: // 2 pixels = mono + alpha,... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
leal -0x1(%r15), %eax
cmpl $0x2, %eax
jb 0x38ab6
cmpl $0x3, %r15d
je 0x38a9c
cmpl $0x4, %r15d
jne 0x38ad5
testl %ebp, %ebp
je 0x38b07
movb 0x2(%r14), %al
movb (%r14), %cl
movb 0x1(%r14), %dl
leaq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image_write.h |
stbiw__jpg_processDU(stbi__write_context*, int*, int*, float*, 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, 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][0], HTAC[0xF0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl %r9d, 0x20(%rsp)
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq 0x198(%rsp), %rcx
movzwl (%rcx), %eax
movw %ax, 0x1c(%rsp)
movzwl 0x2(%rcx), %eax
movw %ax, 0x1e(%r... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image_write.h |
stbiw__jpg_DCT(float*, float*, float*, float*, float*, float*, float*, float*) | static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) {
float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p;
float z1, z2, z3, z4, z5, z11, z13;
float tmp0 = d0 + d7;
float tmp7 = d0 - d7;
float... | movq 0x10(%rsp), %r10
movq 0x8(%rsp), %rax
movss (%rdi), %xmm2
movss (%rsi), %xmm0
movss (%rdx), %xmm4
movss (%rcx), %xmm3
movss (%r8), %xmm5
movss (%r9), %xmm6
movss (%rax), %xmm7
movss (%r10), %xmm8
movaps %xmm2, %xmm1
addss %xmm8, %xmm1
subss %xmm8, %xmm2
movaps %xmm0, %xmm8
addss %xmm7, %xmm8
subss %xmm7, %xmm0
mov... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/extlibs/headers/stb_image/stb_image_write.h |
sf::RenderTarget::mapPixelToCoords(sf::Vector2<int> const&, sf::View const&) const | Vector2f RenderTarget::mapPixelToCoords(const Vector2i& point, const View& view) const
{
// First, convert from viewport coordinates to homogeneous coordinates
Vector2f normalized;
IntRect viewport = getViewport(view);
normalized.x = -1.f + 2.f * (point.x - viewport.left) / viewport.width;
normalize... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %rdx, %rsi
callq 0x395d6
movl (%r15), %ecx
subl %eax, %ecx
cvtsi2ss %ecx, %xmm0
cvtsi2ss %edx, %xmm1
addss %xmm0, %xmm0
divss %xmm1, %xmm0
addss 0x9b936(%rip), %xmm0 # 0xd5004
movss %xmm0, (%... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::draw(sf::Vertex const*, unsigned long, sf::PrimitiveType, sf::RenderStates const&) | void RenderTarget::draw(const Vertex* vertices, std::size_t vertexCount,
PrimitiveType type, const RenderStates& states)
{
// Nothing to draw?
if (!vertices || (vertexCount == 0))
return;
// GL_QUADS is unavailable on OpenGL ES
#ifdef SFML_OPENGL_ES
if (type == Q... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x39a77
movq %r8, %r14
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x1d8(%rdi), %rdi
callq 0x3950f
testb %al, %al
jne 0x3985d
movq (%rbx), %ra... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::setupDraw(bool, sf::RenderStates const&) | void RenderTarget::setupDraw(bool useVertexCache, const RenderStates& states)
{
// First set the persistent OpenGL states if it's the very first call
if (!m_cache.glStatesSet)
resetGLStates();
if (useVertexCache)
{
// Since vertices are transformed, we must use an identity transform to ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x0, 0x159(%rdi)
jne 0x39aa6
movq %r14, %rdi
callq 0x3a0f8
testb %bpl, %bpl
je 0x39ade
cmpb $0x1, 0x158(%r14)
jne 0x39abf
cmpb $0x0, 0x181(%r14)
jne 0x39ae7
callq 0xcc00
leaq 0xa3315(%rip), %rdi # 0xdcde0
le... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::setActive(bool) | bool RenderTarget::setActive(bool active)
{
// Mark this RenderTarget as active or no longer active in the tracking map
{
sf::Lock lock(mutex);
Uint64 contextId = Context::getActiveContextId();
ContextRenderTargetMap::iterator iter = contextRenderTargetMap.find(contextId);
if ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xf4c1c(%rip), %rsi # 0x12ea90
movq %rsp, %rdi
callq 0x225c4
callq 0x1d366
movq %rax, 0x8(%rsp)
movq 0xf4c1b(%rip), %rdx # 0x12eaa8
leaq 0xf4c0c(%rip), %rsi # 0x12eaa0
movq %rsi, %rcx
testq %rdx, %rdx
je 0x39ebb
leaq 0xf4... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::pushGLStates() | void RenderTarget::pushGLStates()
{
if (isActive(m_id) || setActive(true))
{
#ifdef SFML_DEBUG
// make sure that the user didn't leave an unchecked OpenGL error
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
err() << "OpenGL error... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1d8(%rdi), %rdi
callq 0x3950f
testb %al, %al
jne 0x39f80
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x18(%rax)
testb %al, %al
je 0x3a0e6
callq 0xc460
testl %eax, %eax
je 0x3a003
movl %eax, %ebp
callq 0x2237c
movq %rax, %r14
leaq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::popGLStates() | void RenderTarget::popGLStates()
{
if (isActive(m_id) || setActive(true))
{
glCheck(glMatrixMode(GL_PROJECTION));
glCheck(glPopMatrix());
glCheck(glMatrixMode(GL_MODELVIEW));
glCheck(glPopMatrix());
glCheck(glMatrixMode(GL_TEXTURE));
glCheck(glPopMatrix());
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1d8(%rdi), %rdi
callq 0x3950f
testb %al, %al
jne 0x3a38b
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x18(%rax)
testb %al, %al
je 0x3a46b
movl $0x1701, %edi # imm = 0x1701
callq 0xcc90
leaq 0xa2a44(%rip), %rbx # 0xdcde0
leaq 0xa2e32(%rip... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::applyBlendMode(sf::BlendMode const&) | void RenderTarget::applyBlendMode(const BlendMode& mode)
{
// Apply the blend mode, falling back to the non-separate versions if necessary
if (GLEXT_blend_func_separate)
{
glCheck(GLEXT_glBlendFuncSeparate(
factorToGlConstant(mode.colorSrcFactor), factorToGlConstant(mode.colorDstFactor),... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf46c8(%rip), %rax # 0x12eb54
cmpl $0x0, (%rax)
je 0x3a4e8
leaq 0xf4810(%rip), %rax # 0x12eca8
movq (%rax), %r13
movl (%r14), %edi
callq 0x3a860
movl %eax, %ebp
movl 0x4(%r14), %edi
callq 0x3a860
m... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::initialize() | void RenderTarget::initialize()
{
// Setup the default and current views
m_defaultView.reset(FloatRect(0, 0, static_cast<float>(getSize().x), static_cast<float>(getSize().y)));
m_view = m_defaultView;
// Set GL states only on first draw, so that we don't pollute user's states
m_cache.glStatesSet = ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
shrq $0x20, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
leaq 0x10(%rsp), %rsi
movq $... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::applyCurrentView() | void RenderTarget::applyCurrentView()
{
// Set the viewport
IntRect viewport = getViewport(m_view);
int top = getSize().y - (viewport.top + viewport.height);
glCheck(glViewport(viewport.left, top, viewport.width, viewport.height));
// Set the projection matrix
glCheck(glMatrixMode(GL_PROJECTION... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb0(%rdi), %r14
movq %r14, %rsi
callq 0x395d6
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
shrq $0x20, %rax
movq %r15, %rdx
shrq $0x20, %rdx
movq %r12, %rcx
shrq $0x20, %rcx
addl %ecx, %edx
subl %edx, %ea... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderTarget::applyTransform(sf::Transform const&) | void RenderTarget::applyTransform(const Transform& transform)
{
// No need to call glMatrixMode(GL_MODELVIEW), it is always the
// current mode (for optimization purpose, since it's the most used)
if (transform == Transform::Identity)
glCheck(glLoadIdentity());
else
glCheck(glLoadMatrixf... | pushq %rbx
movq %rsi, %rbx
leaq 0xa4e61(%rip), %rsi # 0xdf768
movq %rbx, %rdi
callq 0x40bbb
testb %al, %al
je 0x3a931
callq 0xcc00
leaq 0xa24c1(%rip), %rdi # 0xdcde0
leaq 0xa29f8(%rip), %rdx # 0xdd31e
movl $0x276, %esi # imm = 0x276
popq %rbx
jmp 0x452f8
movq %rbx, %rdi
callq 0x40310
movq %rax, %... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
sf::RenderWindow::setActive(bool) | bool RenderWindow::setActive(bool active)
{
bool result = Window::setActive(active);
// Update RenderTarget tracking
if (result)
RenderTarget::setActive(active);
// If FBOs are available, make sure none are bound when we
// try to draw to the default framebuffer of the RenderWindow
if ... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x14ada
movl %eax, %ebx
testb %al, %al
je 0x3ae38
addq $0x30, %r14
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x39e60
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x3ae51
callq 0x43ae4
testb %al, %al
je 0x3ae51
callq 0x43b94
movb $0x1, %bl
movl %ebx, %eax
popq %... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderWindow.cpp |
non-virtual thunk to sf::RenderWindow::setActive(bool) | bool RenderWindow::setActive(bool active)
{
bool result = Window::setActive(active);
// Update RenderTarget tracking
if (result)
RenderTarget::setActive(active);
// If FBOs are available, make sure none are bound when we
// try to draw to the default framebuffer of the RenderWindow
if ... | addq $-0x30, %rdi
jmp 0x3ae14
nop
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderWindow.cpp |
sf::Shader::Shader() | Shader::Shader() :
m_shaderProgram (0),
m_currentTexture(-1),
m_textures (),
m_uniforms ()
{
} | pushq %rbx
movq %rdi, %rbx
callq 0x1ebc8
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, (%rbx)
leaq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x8(%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
leaq 0x40(%rbx), %rax
movups %xmm0, 0x50(%r... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
(anonymous namespace)::getFileContents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<char, std::allocator<char>>&) | bool getFileContents(const std::string& filename, std::vector<char>& buffer)
{
std::ifstream file(filename.c_str(), std::ios_base::binary);
if (file)
{
file.seekg(0, std::ios_base::end);
std::streamsize size = file.tellg();
if (size > 0)
{
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0xd250
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ebp
testb $0x5, %bpl
jne 0x3b188
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x2,... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::compile(char const*, char const*, char const*) | bool Shader::compile(const char* vertexShaderCode, const char* geometryShaderCode, const char* fragmentShaderCode)
{
TransientContextLock lock;
// First make sure that we can use shaders
if (!isAvailable())
{
err() << "Failed to create a shader: your system doesn't support shaders "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
movq %rdi, %r14
movq %rsi, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
leaq 0x3(%rsp), %rdi
callq 0x1ebe4
callq 0x3d402
testb %al, %al
je 0x3b38b
cmpq $0x0, 0x8(%rsp)
je 0x3b211
callq 0x3d592
testb %al... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::loadFromFile(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&) | bool Shader::loadFromFile(const std::string& vertexShaderFilename, const std::string& fragmentShaderFilename)
{
// Read the vertex shader file
std::vector<char> vertexShader;
if (!getFileContents(vertexShaderFilename, vertexShader))
{
err() << "Failed to open vertex shader file \"" << vertexShad... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r15, %rdi
callq 0x3b0f8
testb %al, %al
je 0x3bb40
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::loadFromFile(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool Shader::loadFromFile(const std::string& vertexShaderFilename, const std::string& geometryShaderFilename, const std::string& fragmentShaderFilename)
{
// Read the vertex shader file
std::vector<char> vertexShader;
if (!getFileContents(vertexShaderFilename, vertexShader))
{
err() << "Failed t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r12, %rdi
callq 0x3b0f8
testb %al, %al
je 0x3bd29
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::loadFromStream(sf::InputStream&, sf::Shader::Type) | bool Shader::loadFromStream(InputStream& stream, Type type)
{
// Read the shader code from the stream
std::vector<char> shader;
if (!getStreamContents(stream, shader))
{
err() << "Failed to read shader from stream" << std::endl;
return false;
}
// Compile the shader program
... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, %rdi
callq 0x3c055
testb %al, %al
je 0x3bfaf
movq (%rsp), %rcx
cmpl $0x1, %ebp
je 0x3bff6
testl %ebp, %ebp
jne 0x3c007
movq %rbx, %rdi
movq %rcx... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
(anonymous namespace)::getStreamContents(sf::InputStream&, std::vector<char, std::allocator<char>>&) | bool getStreamContents(sf::InputStream& stream, std::vector<char>& buffer)
{
bool success = true;
sf::Int64 size = stream.getSize();
if (size > 0)
{
buffer.resize(static_cast<std::size_t>(size));
stream.seek(0);
sf::Int64 read = stream.read(&buffer... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
testq %rax, %rax
jle 0x3c09e
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d91e
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
callq *0x18(%rax)
movq (%rbx), %rsi
movq (%r14), %rax
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::loadFromStream(sf::InputStream&, sf::InputStream&, sf::InputStream&) | bool Shader::loadFromStream(InputStream& vertexShaderStream, InputStream& geometryShaderStream, InputStream& fragmentShaderStream)
{
// Read the vertex shader code from the stream
std::vector<char> vertexShader;
if (!getStreamContents(vertexShaderStream, vertexShader))
{
err() << "Failed to read... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, %rdi
callq 0x3c055
testb %al, %al
je 0x3c2b9
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::setUniform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, sf::Texture const&) | void Shader::setUniform(const std::string& name, const Texture& texture)
{
if (m_shaderProgram)
{
TransientContextLock lock;
// Find the location of the variable in the shader
int location = getUniformLocation(name);
if (location != -1)
{
// Store the locatio... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, (%rdi)
je 0x3ca41
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xb(%rsp), %rdi
callq 0x1ebe4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3cb1e
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x3ca37
movq 0x18(%r15), %rcx
leaq 0x10(%r15), %rdx
movq %rd... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::getUniformLocation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | int Shader::getUniformLocation(const std::string& name)
{
// Check the cache
UniformTable::const_iterator it = m_uniforms.find(name);
if (it != m_uniforms.end())
{
// Already in cache, return it
return it->second;
}
else
{
// Not in cache, request the location from Op... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %r15
movq %r15, %rdi
callq 0x3ddf8
leaq 0x40(%rbx), %rcx
cmpq %rcx, %rax
je 0x3cb4e
movl 0x40(%rax), %ebx
jmp 0x3cc13
leaq 0xf221b(%rip), %rax # 0x12ed70
movl (%rbx), %edi
movq (%r14), %rsi
callq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::setUniformArray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, sf::priv::Matrix<3ul, 3ul> const*, unsigned long) | void Shader::setUniformArray(const std::string& name, const Glsl::Mat3* matrixArray, std::size_t length)
{
const std::size_t matrixSize = 3 * 3;
std::vector<float> contiguous(matrixSize * length);
for (std::size_t i = 0; i < length; ++i)
priv::copyMatrix(matrixArray[i].array, matrixSize, &contiguou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq (%rcx,%rcx,8), %rsi
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
callq 0x3d7cc
testq %rbx, %rbx
je 0x3d061
xorl %r13d, %r13d
movq %rbx, %rbp
leaq (%r12,%r13), %rdi
movq 0x10(%... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::setUniformArray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, sf::priv::Matrix<4ul, 4ul> const*, unsigned long) | void Shader::setUniformArray(const std::string& name, const Glsl::Mat4* matrixArray, std::size_t length)
{
const std::size_t matrixSize = 4 * 4;
std::vector<float> contiguous(matrixSize * length);
for (std::size_t i = 0; i < length; ++i)
priv::copyMatrix(matrixArray[i].array, matrixSize, &contiguou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rsi
shlq $0x4, %rsi
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
callq 0x3d7cc
testq %rbx, %rbx
je 0x3d15a
xorl %r13d, %r13d
movq %rbx, %rbp
leaq (%r12,%r13), %rdi
movq... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::bind(sf::Shader const*) | void Shader::bind(const Shader* shader)
{
TransientContextLock lock;
// Make sure that we can use shaders
if (!isAvailable())
{
err() << "Failed to bind or unbind shader: your system doesn't support shaders "
<< "(you should test Shader::isAvailable() before trying to use the Shad... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x1ebe4
callq 0x3d402
testb %al, %al
je 0x3d360
testq %rbx, %rbx
je 0x3d3b9
movl (%rbx), %edi
testl %edi, %edi
je 0x3d3b9
leaq 0xf1b17(%rip), %rax # 0x12ee30
callq *(%rax)
leaq 0xa0586(%rip), %rdi # 0xdd8a8
leaq 0xa0c50(%rip), %rdx # 0xd... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::bindTextures() const | void Shader::bindTextures() const
{
TextureTable::const_iterator it = m_textures.begin();
for (std::size_t i = 0; i < m_textures.size(); ++i)
{
GLint index = static_cast<GLsizei>(i + 1);
glCheck(GLEXT_glUniform1i(it->first, index));
glCheck(GLEXT_glActiveTexture(GLEXT_GL_TEXTURE0 + i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x30(%rdi)
je 0x3d55d
movq %rdi, %rbx
movq 0x20(%rdi), %r14
xorl %ebp, %ebp
leaq 0xa03ba(%rip), %r15 # 0xdd8a8
leaq 0xa1208(%rip), %r13 # 0xde6fd
leaq 0x1(%rbp), %r12
movl 0x20(%r14), %edi
movl %r12d, %esi
leaq 0xf18a1(%rip)... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Shader::UniformBinder::UniformBinder(sf::Shader&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | UniformBinder(Shader& shader, const std::string& name) :
savedProgram(0),
currentProgram(castToGlHandle(shader.m_shaderProgram)),
location(-1)
{
if (currentProgram)
{
// Enable program object
glCheck(savedProgram = GLEXT_glGetHandle(GLEXT_GL_PROGRAM_OBJECT));
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x1(%rdi), %rbx
movq %rbx, %rdi
callq 0x1ebe4
movl $0x0, 0x4(%r14)
movl (%r12), %eax
movl %eax, 0x8(%r14)
movl $0xffffffff, 0xc(%r14) # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x3d701
leaq 0xf16a4(%rip), %rax #... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Shader.cpp |
sf::Texture::Texture(sf::Texture const&) | Texture::Texture(const Texture& copy) :
m_size (0, 0),
m_actualSize (0, 0),
m_texture (0),
m_isSmooth (copy.m_isSmooth),
m_sRgb (copy.m_sRgb),
m_isRepeated (copy.m_isRepeated),
m_pixelsFlipped(false),
m_fboAttachment(false),
m_hasMipmap (false),
m_cacheId (getUniqueId())
{
if (c... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1ebc8
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
movb 0x14(%r14), %al
movb %al, 0x14(%rbx)
movb 0x15(%r14), %al
movb %al, 0x15(%rbx)
movb 0x16(%r14), %al
movb %al, 0x16(%rbx)
movw $0x0, 0x17(%rbx)
movb $0x0, 0x1... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::create(unsigned int, unsigned int) | bool Texture::create(unsigned int width, unsigned int height)
{
// Check if texture parameters are valid before creating it
if ((width == 0) || (height == 0))
{
err() << "Failed to create texture, invalid size (" << width << "x" << height << ")" << std::endl;
return false;
}
Transie... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r12d
testl %esi, %esi
setne %al
testl %edx, %edx
setne %cl
testb %cl, %al
jne 0x3e27e
callq 0x2237c
movq %rax, %rbx
leaq 0xa0703(%rip), %rsi # 0xde903
movl $0x28, %edx
movq %rax, %rdi
callq 0xca70
movl %r1... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::getValidSize(unsigned int) | unsigned int Texture::getValidSize(unsigned int size)
{
if (GLEXT_texture_non_power_of_two)
{
// If hardware supports NPOT textures, then just return the unmodified size
return size;
}
else
{
// If hardware doesn't support NPOT textures, we calculate the nearest power of two
... | leaq 0xf02d9(%rip), %rax # 0x12eb6c
cmpl $0x0, (%rax)
je 0x3e89b
movl %edi, %eax
retq
movl $0x1, %ecx
movl %ecx, %eax
leal (%rax,%rax), %ecx
cmpl %edi, %eax
jb 0x3e8a0
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::loadFromImage(sf::Image const&, sf::Rect<int> const&) | bool Texture::loadFromImage(const Image& image, const IntRect& area)
{
// Retrieve the image size
int width = static_cast<int>(image.getSize().x);
int height = static_cast<int>(image.getSize().y);
// Load the entire image if the source area is either empty or contains the whole image
if (area.width... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x243e2
movq %rax, %r15
movq %r13, %rdi
callq 0x243e2
movl 0x8(%rbx), %edx
testl %edx, %edx
je 0x3eba9
movl 0xc(%rbx), %ecx
testl %ecx, %ecx
je 0x3eba9
shrq $0x20... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::update(unsigned char const*, unsigned int, unsigned int, unsigned int, unsigned int) | void Texture::update(const Uint8* pixels, unsigned int width, unsigned int height, unsigned int x, unsigned int y)
{
assert(x + width <= m_size.x);
assert(y + height <= m_size.y);
if (pixels && m_texture)
{
TransientContextLock lock;
// Make sure that the current texture binding will b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %edx, %r13d
leal (%rbp,%r13), %eax
cmpl (%rdi), %eax
ja 0x3f15f
movl %r9d, %r15d
movl %ecx, %r14d
movq %rdi, %rbx
leal (%r15,%r14), %eax
cmpl 0x4(%rdi), %eax
ja 0x3f17e
movq %rsi, %r12
testq %rsi, %rsi
je 0x3f150
cmp... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::update(sf::Texture const&, unsigned int, unsigned int) | void Texture::update(const Texture& texture, unsigned int x, unsigned int y)
{
assert(x + texture.m_size.x <= m_size.x);
assert(y + texture.m_size.y <= m_size.y);
if (!m_texture || !texture.m_texture)
return;
#ifndef SFML_OPENGL_ES
{
TransientContextLock lock;
// Make sure th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl (%rsi), %eax
addl %edx, %eax
cmpl (%rdi), %eax
ja 0x3f6d7
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rsi), %eax
addl %ecx, %eax
cmpl 0x4(%rdi), %eax
ja 0x3f6f6
cmpl $0x0, 0x10(%rbx)
je 0x3f6c8
cmpl $0x0, 0x10(%r15)
je... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::update(sf::Window const&, unsigned int, unsigned int) | void Texture::update(const Window& window, unsigned int x, unsigned int y)
{
assert(x + window.getSize().x <= m_size.x);
assert(y + window.getSize().y <= m_size.y);
if (m_texture && window.setActive(true))
{
TransientContextLock lock;
// Make sure that the current texture binding will ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x14a20
addl %r14d, %eax
cmpl (%rbx), %eax
ja 0x3f94e
movq %r15, %rdi
callq 0x14a20
shrq $0x20, %rax
addl %ebp, %eax
cmpl 0x4(%rbx), %eax
ja 0x3f96d
cmpl $0x0, 0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::setSmooth(bool) | void Texture::setSmooth(bool smooth)
{
if (smooth != m_isSmooth)
{
m_isSmooth = smooth;
if (m_texture)
{
TransientContextLock lock;
// Make sure that the current texture binding will be preserved
priv::TextureSaver save;
glCheck(glBindTe... | pushq %rbx
subq $0x10, %rsp
cmpb %sil, 0x14(%rdi)
je 0x3fab1
movq %rdi, %rbx
movb %sil, 0x14(%rdi)
cmpl $0x0, 0x10(%rdi)
je 0x3fab1
leaq 0xb(%rsp), %rdi
callq 0x1ebe4
leaq 0xc(%rsp), %rdi
callq 0x40238
movl 0x10(%rbx), %esi
movl $0xde1, %edi # imm = 0xDE1
callq 0xcb50
leaq 0x9ee34(%rip), %rdi # 0xde830
l... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::setRepeated(bool) | void Texture::setRepeated(bool repeated)
{
if (repeated != m_isRepeated)
{
m_isRepeated = repeated;
if (m_texture)
{
TransientContextLock lock;
// Make sure that the current texture binding will be preserved
priv::TextureSaver save;
stat... | pushq %r14
pushq %rbx
pushq %rax
cmpb %sil, 0x16(%rdi)
je 0x3fce6
movq %rdi, %rbx
movb %sil, 0x16(%rdi)
cmpl $0x0, 0x10(%rdi)
je 0x3fce6
leaq 0x3(%rsp), %rdi
callq 0x1ebe4
leaq 0x4(%rsp), %rdi
callq 0x40238
movb 0xef00d(%rip), %al # 0x12eb30
testb %al, %al
je 0x3fcee
cmpb $0x0, 0x16(%rbx)
jne 0x3fc1f
cmpb $0x0, 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::bind(sf::Texture const*, sf::Texture::CoordinateType) | void Texture::bind(const Texture* texture, CoordinateType coordinateType)
{
TransientContextLock lock;
if (texture && texture->m_texture)
{
// Bind the texture
glCheck(glBindTexture(GL_TEXTURE_2D, texture->m_texture));
// Check if we need to define a special texture matrix
... | pushq %rbp
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xf(%rsp), %rdi
callq 0x1ebe4
testq %rbx, %rbx
je 0x4004a
movl 0x10(%rbx), %esi
testl %esi, %esi
je 0x4004a
movl $0xde1, %edi # imm = 0xDE1
callq 0xcb50
leaq 0x9e910(%rip), %rdi # 0xde830
leaq 0x9f6ab(%rip), %rdx # 0xdf5d2
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Texture::swap(sf::Texture&) | void Texture::swap(Texture& right)
{
std::swap(m_size, right.m_size);
std::swap(m_actualSize, right.m_actualSize);
std::swap(m_texture, right.m_texture);
std::swap(m_isSmooth, right.m_isSmooth);
std::swap(m_sRgb, right.m_sRgb);
std::swap(m_isRepeated, right.m_i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rcx
movq %rcx, (%rdi)
movq %rax, (%rsi)
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%rsi)
movl 0x10(%rdi), %eax
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Texture.cpp |
sf::Transform::getInverse() const | Transform Transform::getInverse() const
{
// Compute the determinant
float det = m_matrix[0] * (m_matrix[15] * m_matrix[5] - m_matrix[7] * m_matrix[13]) -
m_matrix[1] * (m_matrix[15] * m_matrix[4] - m_matrix[7] * m_matrix[12]) +
m_matrix[3] * (m_matrix[13] * m_matrix[4] - m_matri... | movq %rdi, %rax
movss (%rsi), %xmm6
movss 0x4(%rsi), %xmm0
movss 0x3c(%rsi), %xmm3
movss 0x14(%rsi), %xmm1
movss 0x1c(%rsi), %xmm2
movss 0x34(%rsi), %xmm4
movaps %xmm4, %xmm7
mulss %xmm2, %xmm7
movaps %xmm3, %xmm5
mulss %xmm1, %xmm5
subss %xmm7, %xmm5
movss 0x10(%rsi), %xmm8
movss 0x30(%rsi), %xmm13
movaps %xmm13, %xmm... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transform.cpp |
sf::Transform::combine(sf::Transform const&) | Transform& Transform::combine(const Transform& transform)
{
const float* a = m_matrix;
const float* b = transform.m_matrix;
*this = Transform(a[0] * b[0] + a[4] * b[1] + a[12] * b[3],
a[0] * b[4] + a[4] * b[5] + a[12] * b[7],
a[0] * b[12] + a[4] * b[13] + a[1... | movq %rdi, %rax
movss 0x10(%rdi), %xmm11
movss (%rsi), %xmm5
movss 0x4(%rsi), %xmm6
movaps %xmm11, %xmm0
mulss %xmm6, %xmm0
movss (%rdi), %xmm14
movss 0x4(%rdi), %xmm1
movaps %xmm14, %xmm3
mulss %xmm5, %xmm3
addss %xmm0, %xmm3
movss 0x30(%rdi), %xmm10
movss 0xc(%rsi), %xmm2
movaps %xmm10, %xmm0
mulss %xmm2, %xmm0
addss... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transform.cpp |
sf::Transform::rotate(float) | Transform& Transform::rotate(float angle)
{
float rad = angle * 3.141592654f / 180.f;
float cos = std::cos(rad);
float sin = std::sin(rad);
Transform rotation(cos, -sin, 0,
sin, cos, 0,
0, 0, 1);
return combine(rotation);
} | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
mulss 0x9eea2(%rip), %xmm0 # 0xdf760
divss 0x9ee9e(%rip), %xmm0 # 0xdf764
movss %xmm0, 0x8(%rsp)
callq 0xc6a0
movss %xmm0, 0xc(%rsp)
movss 0x8(%rsp), %xmm0
callq 0xc7a0
movaps 0x9df37(%rip), %xmm1 # 0xde820
xorps %xmm0, %xmm1
leaq 0x10(%rsp), %rsi
movss 0xc(%rsp), %x... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transform.cpp |
sf::Transform::rotate(float, float, float) | Transform& Transform::rotate(float angle, float centerX, float centerY)
{
float rad = angle * 3.141592654f / 180.f;
float cos = std::cos(rad);
float sin = std::sin(rad);
Transform rotation(cos, -sin, centerX * (1 - cos) + centerY * sin,
sin, cos, centerY * (1 - cos) - centerX * ... | pushq %rbx
subq $0x50, %rsp
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0xc(%rsp)
movq %rdi, %rbx
mulss 0x9ee02(%rip), %xmm0 # 0xdf760
divss 0x9edfe(%rip), %xmm0 # 0xdf764
movss %xmm0, (%rsp)
callq 0xc6a0
movss %xmm0, 0x4(%rsp)
movss (%rsp), %xmm0
callq 0xc7a0
movaps 0x9de99(%rip), %xmm1 # 0xde820
xorps %xmm0, %xmm1
m... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transform.cpp |
sf::Transform::scale(float, float, float, float) | Transform& Transform::scale(float scaleX, float scaleY, float centerX, float centerY)
{
Transform scaling(scaleX, 0, centerX * (1 - scaleX),
0, scaleY, centerY * (1 - scaleY),
0, 0, 1);
return combine(scaling);
} | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movss 0x96970(%rip), %xmm4 # 0xd73fc
movaps %xmm4, %xmm5
subss %xmm0, %xmm5
mulss %xmm2, %xmm5
subss %xmm1, %xmm4
mulss %xmm3, %xmm4
movq %rsp, %rsi
movss %xmm0, (%rsi)
xorl %eax, %eax
movl %eax, 0x10(%rsi)
movss %xmm5, 0x30(%rsi)
movl %eax, 0x4(%rsi)
movss %xmm1, 0x14(%rs... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transform.cpp |
sf::Transformable::Transformable() | Transformable::Transformable() :
m_origin (0, 0),
m_position (0, 0),
m_rotation (0),
m_scale (1, 1),
m_transform (),
m_transformNeedUpdate (true),
m_inverseTransform (),
m_inverseTransformNeedUpdate(true)
{
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xea97f(%rip), %rax # 0x12b5d0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movl $0x0, 0x18(%rdi)
movabsq $0x3f8000003f800000, %rax # imm = 0x3F8000003F800000
movq %rax, 0x1c(%rdi)
addq $0x24, %rdi
callq 0x40290
movb $0x1, %bpl
movb %bpl, 0x64(%r... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transformable.cpp |
sf::Transformable::rotate(float) | void Transformable::rotate(float angle)
{
setRotation(m_rotation + angle);
} | pushq %rbx
movq %rdi, %rbx
addss 0x18(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x9e9c3(%rip), %xmm1 # 0xdf7a8
callq 0xcc30
cvtsd2ss %xmm0, %xmm0
movss 0x9e9ba(%rip), %xmm1 # 0xdf7b0
addss %xmm0, %xmm1
xorps %xmm2, %xmm2
movaps %xmm0, %xmm3
cmpltss %xmm2, %xmm3
andps %xmm3, %xmm1
andnps %xmm0, %xmm3
orps %xmm1, %x... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transformable.cpp |
sf::Transformable::getTransform() const | const Transform& Transformable::getTransform() const
{
// Recompute the combined transform if needed
if (m_transformNeedUpdate)
{
float angle = -m_rotation * 3.141592654f / 180.f;
float cosine = static_cast<float>(std::cos(angle));
float sine = static_cast<float>(std::sin(angle));... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x64(%rdi)
jne 0x40f59
movss 0x18(%rbx), %xmm0
mulss 0x9e929(%rip), %xmm0 # 0xdf7b4
divss 0x9e8d1(%rip), %xmm0 # 0xdf764
movss %xmm0, 0x10(%rsp)
callq 0xc6a0
movss %xmm0, 0x14(%rsp)
movss 0x10(%rsp), %xmm0
callq 0xc7a0
movaps %xmm0, %xmm2
movss 0x1... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Transformable.cpp |
sf::View::View() | View::View() :
m_center (),
m_size (),
m_rotation (0),
m_viewport (0, 0, 1, 1),
m_transformUpdated (false),
m_invTransformUpdated(false)
{
reset(FloatRect(0, 0, 1000, 1000));
} | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
movups %xmm0, (%rdi)
movabsq $0x3f8000003f800000, %rax # imm = 0x3F8000003F800000
movq %rax, 0x1c(%rdi)
addq $0x24, %rdi
callq 0x40290
leaq 0x64(%rbx), %rdi
callq 0x40290
movw $0x0, 0xa4(%rbx)
movaps 0x9e7be(%rip), %xmm0 # 0xdf7d0
movups %xmm0, (%... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/View.cpp |
sf::View::reset(sf::Rect<float> const&) | void View::reset(const FloatRect& rectangle)
{
m_center.x = rectangle.left + rectangle.width / 2.f;
m_center.y = rectangle.top + rectangle.height / 2.f;
m_size.x = rectangle.width;
m_size.y = rectangle.height;
m_rotation = 0;
m_transformUpdated = false;
m_invTransformUpdated = false;... | movss 0x8(%rsi), %xmm0
movss 0x98d29(%rip), %xmm1 # 0xd9d54
movaps %xmm0, %xmm2
mulss %xmm1, %xmm2
addss (%rsi), %xmm2
movss %xmm2, (%rdi)
movss 0xc(%rsi), %xmm2
mulss %xmm2, %xmm1
addss 0x4(%rsi), %xmm1
movss %xmm1, 0x4(%rdi)
movss %xmm0, 0x8(%rdi)
movss %xmm2, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movw $0x0, 0xa4(%rdi)
... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/View.cpp |
sf::View::View(sf::Rect<float> const&) | View::View(const FloatRect& rectangle) :
m_center (),
m_size (),
m_rotation (0),
m_viewport (0, 0, 1, 1),
m_transformUpdated (false),
m_invTransformUpdated(false)
{
reset(rectangle);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
movups %xmm0, (%rdi)
movabsq $0x3f8000003f800000, %rax # imm = 0x3F8000003F800000
movq %rax, 0x1c(%rdi)
addq $0x24, %rdi
callq 0x40290
leaq 0x64(%rbx), %rdi
callq 0x40290
xorl %eax, %eax
movw %ax, 0xa4(%rbx)
movs... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/View.cpp |
sf::View::View(sf::Vector2<float> const&, sf::Vector2<float> const&) | View::View(const Vector2f& center, const Vector2f& size) :
m_center (center),
m_size (size),
m_rotation (0),
m_viewport (0, 0, 1, 1),
m_transformUpdated (false),
m_invTransformUpdated(false)
{
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
movaps 0x9e6d0(%rip), %xmm0 # 0xdf7e0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
addq $0x24, %rdi
callq 0x40290
leaq 0x64(%rbx), %rdi
callq 0x40290
movw $0x0, 0xa4(%rbx)
popq %rbx
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/View.cpp |
sf::View::getTransform() const | const Transform& View::getTransform() const
{
// Recompute the matrix if needed
if (!m_transformUpdated)
{
// Rotation components
float angle = m_rotation * 3.141592654f / 180.f;
float cosine = static_cast<float>(std::cos(angle));
float sine = static_cast<float>(std::sin(a... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x0, 0xa4(%rdi)
jne 0x413c3
movss 0x10(%rbx), %xmm0
mulss 0x9e4a0(%rip), %xmm0 # 0xdf760
divss 0x9e49c(%rip), %xmm0 # 0xdf764
movss %xmm0, 0x10(%rsp)
callq 0xc6a0
movss %xmm0, 0x14(%rsp)
movss 0x10(%rsp), %xmm0
callq 0xc7a0
movss (%rbx), %xmm6
movss 0x4... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/View.cpp |
sfogl_LoadFunctions | void sfogl_LoadFunctions()
{
ClearExtensionVars();
for (int i = 0; i < g_extensionMapSize; ++i)
{
if (sf::Context::isExtensionAvailable(ExtensionMap[i].extensionName))
LoadExtension(ExtensionMap[i]);
}
} | pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
movl %eax, 0xed628(%rip) # 0x12eb40
movl %eax, 0xed626(%rip) # 0x12eb44
movl %eax, 0xed624(%rip) # 0x12eb48
movl %eax, 0xed622(%rip) # 0x12eb4c
movl %eax, 0xed620(%rip) # 0x12eb50
movl %eax, 0xed61e(%rip) # 0x12eb54
movl %eax, 0xed61c(%rip) # ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLLoader.cpp |
Load_ARB_multitexture() | static sf::GlFunctionPointer glLoaderGetProcAddress(const char* name)
{
return sf::Context::getFunction(name);
} | pushq %rbp
pushq %r14
pushq %rbx
leaq 0x9e3ff(%rip), %rdi # 0xdf9fe
callq 0x1d372
movq %rax, 0xed58d(%rip) # 0x12eb98
xorl %ebx, %ebx
testq %rax, %rax
sete %bl
leaq 0x9e3f7(%rip), %rdi # 0xdfa11
callq 0x1d372
movq %rax, 0xed57a(%rip) # 0x12eba0
leal 0x1(%rbx), %ebp
testq %rax, %rax
cmovnel %ebx, %ebp
le... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLLoader.cpp |
Load_ARB_shader_objects() | static sf::GlFunctionPointer glLoaderGetProcAddress(const char* name)
{
return sf::Context::getFunction(name);
} | pushq %rbp
pushq %r14
pushq %rbx
leaq 0x9e2df(%rip), %rdi # 0xdfdbc
callq 0x1d372
movq %rax, 0xed21f(%rip) # 0x12ed08
xorl %ebx, %ebx
testq %rax, %rax
sete %bl
leaq 0x9e2d6(%rip), %rdi # 0xdfdce
callq 0x1d372
movq %rax, 0xed20c(%rip) # 0x12ed10
leal 0x1(%rbx), %ebp
testq %rax, %rax
cmovnel %ebx, %ebp
le... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLLoader.cpp |
Load_ARB_vertex_shader() | static sf::GlFunctionPointer glLoaderGetProcAddress(const char* name)
{
return sf::Context::getFunction(name);
} | pushq %rbp
pushq %r14
pushq %rbx
leaq 0x9e1a3(%rip), %rdi # 0xe0090
callq 0x1d372
movq %rax, 0xecf47(%rip) # 0x12ee40
xorl %ebx, %ebx
testq %rax, %rax
sete %bl
leaq 0x9e1a0(%rip), %rdi # 0xe00a8
callq 0x1d372
movq %rax, 0xecf34(%rip) # 0x12ee48
leal 0x1(%rbx), %ebp
testq %rax, %rax
cmovnel %ebx, %ebp
le... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLLoader.cpp |
Load_EXT_framebuffer_object() | static sf::GlFunctionPointer glLoaderGetProcAddress(const char* name)
{
return sf::Context::getFunction(name);
} | pushq %rbp
pushq %rbx
pushq %rax
leaq 0x9e0c6(%rip), %rdi # 0xe049a
callq 0x1d372
movq %rax, 0xecbd8(%rip) # 0x12efb8
xorl %ebx, %ebx
testq %rax, %rax
sete %bl
leaq 0x9e0c0(%rip), %rdi # 0xe04af
callq 0x1d372
movq %rax, 0xecbc5(%rip) # 0x12efc0
leal 0x1(%rbx), %ebp
testq %rax, %rax
cmovnel %ebx, %ebp
le... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLLoader.cpp |
Load_ARB_geometry_shader4() | static sf::GlFunctionPointer glLoaderGetProcAddress(const char* name)
{
return sf::Context::getFunction(name);
} | pushq %rbp
pushq %rbx
pushq %rax
leaq 0x9e092(%rip), %rdi # 0xe0692
callq 0x1d372
movq %rax, 0xeca4c(%rip) # 0x12f058
xorl %ebx, %ebx
testq %rax, %rax
sete %bl
leaq 0x9e08f(%rip), %rdi # 0xe06aa
callq 0x1d372
movq %rax, 0xeca39(%rip) # 0x12f060
leal 0x1(%rbx), %ebp
testq %rax, %rax
cmovnel %ebx, %ebp
le... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLLoader.cpp |
sf::Sprite::setTexture(sf::Texture const&, bool) | void Sprite::setTexture(const Texture& texture, bool resetRect)
{
// Recompute the texture area if requested, or if there was no valid texture & rect before
if (resetRect || (!m_texture && (m_textureRect == sf::IntRect())))
setTextureRect(IntRect(0, 0, texture.getSize().x, texture.getSize().y));
//... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x427d7
movq %rbx, %rdi
callq 0x3e81a
movq %rax, %r15
movq %rbx, %rdi
callq 0x3e81a
shrq $0x20, %rax
movq %rsp, %rsi
movq $0x0, (%rsi)
movl %r15d, 0x8(%rsi)
movl %eax, 0xc(%rsi)
movq %r14, %rdi
callq 0x428c2
jmp 0x427e... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Sprite.cpp |
sf::Sprite::Sprite(sf::Texture const&, sf::Rect<int> const&) | Sprite::Sprite(const Texture& texture, const IntRect& rectangle) :
m_texture (NULL),
m_textureRect()
{
setTexture(texture);
setTextureRect(rectangle);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0xe903b(%rip), %rax # 0x12b870
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x40c44
leaq 0xe8f95(%rip), %rax # 0x12b7e0
movq %rax, (%r15)
leaq 0xe8fb3(%rip), %rax # 0x12b808
movq %rax,... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Sprite.cpp |
sf::VertexBuffer::VertexBuffer(sf::PrimitiveType) | VertexBuffer::VertexBuffer(PrimitiveType type) :
m_buffer (0),
m_size (0),
m_primitiveType(type),
m_usage (Stream)
{
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0xe8c4e(%rip), %rax # 0x12b870
movq %rax, (%rdi)
callq 0x1ebc8
leaq 0xe8c67(%rip), %rax # 0x12b898
movq %rax, (%r14)
xorl %eax, %eax
movl %eax, 0x8(%r14)
movq $0x0, 0x10(%r14)
movl %ebx, 0x18(%r14)
movl %eax, 0x1c(%r14)
addq $0x8, %rsp
popq %... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/VertexBuffer.cpp |
sf::VertexBuffer::VertexBuffer(sf::VertexBuffer const&) | VertexBuffer::VertexBuffer(const VertexBuffer& copy) :
m_buffer (0),
m_size (0),
m_primitiveType(copy.m_primitiveType),
m_usage (copy.m_usage)
{
if (copy.m_buffer && copy.m_size)
{
if (!create(copy.m_size))
{
err() << "Could not create vertex buffer for copying" ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe8b8b(%rip), %rax # 0x12b870
movq %rax, (%rdi)
callq 0x1ebc8
leaq 0xe8ba4(%rip), %rax # 0x12b898
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movl 0x1c(%r14), %eax
movl %eax, 0x1c(... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/VertexBuffer.cpp |
sf::VertexBuffer::create(unsigned long) | bool VertexBuffer::create(std::size_t vertexCount)
{
if (!isAvailable())
return false;
TransientContextLock contextLock;
if (!m_buffer)
glCheck(GLEXT_glGenBuffers(1, &m_buffer));
if (!m_buffer)
{
err() << "Could not create vertex buffer, generation failed" << std::endl;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x432de
testb %al, %al
je 0x42ee1
leaq 0x7(%rsp), %rdi
callq 0x1ebe4
leaq 0x8(%r15), %rbx
cmpl $0x0, 0x8(%r15)
jne 0x42e31
leaq 0xebec1(%rip), %rax # 0x12ecd0
movl $0x1, %edi
movq %rbx, %rsi
callq *(%rax)
leaq 0x9d93e(%rip)... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/VertexBuffer.cpp |
sf::VertexBuffer::update(sf::VertexBuffer const&) | bool VertexBuffer::update(const VertexBuffer& vertexBuffer)
{
#ifdef SFML_OPENGL_ES
return false;
#else
if (!m_buffer || !vertexBuffer.m_buffer)
return false;
TransientContextLock contextLock;
// Make sure that extensions are initialized
sf::priv::ensureExtensionsInit();
if (GLEXT_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x8(%rdi)
je 0x43074
movq %rsi, %r14
cmpl $0x0, 0x8(%rsi)
je 0x43074
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
callq 0x1ebe4
callq 0x45754
leaq 0xebbf7(%rip), %rax # 0x12eb88
cmpl $0x0, (%rax)
leaq 0xebd15(%rip), %r13 # 0x12ecb0
... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/VertexBuffer.cpp |
sf::VertexBuffer::isAvailable() | bool VertexBuffer::isAvailable()
{
Lock lock(isAvailableMutex);
static bool checked = false;
static bool available = false;
if (!checked)
{
checked = true;
TransientContextLock contextLock;
// Make sure that extensions are initialized
sf::priv::ensureExtensionsIni... | pushq %rbx
subq $0x10, %rsp
leaq 0xebd8e(%rip), %rsi # 0x12f078
leaq 0x8(%rsp), %rdi
callq 0x225c4
cmpb $0x0, 0xebd85(%rip) # 0x12f080
jne 0x4332e
movb $0x1, 0xebd7c(%rip) # 0x12f080
leaq 0x7(%rsp), %rdi
callq 0x1ebe4
callq 0x45754
leaq 0xeb83e(%rip), %rax # 0x12eb58
cmpl $0x0, (%rax)
setne 0xebd5d(%rip... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/VertexBuffer.cpp |
sf::VertexBuffer::update(sf::Vertex const*, unsigned long, unsigned int) | bool VertexBuffer::update(const Vertex* vertices, std::size_t vertexCount, unsigned int offset)
{
// Sanity checks
if (!m_buffer)
return false;
if (!vertices)
return false;
if (offset && (offset + vertexCount > m_size))
return false;
TransientContextLock contextLock;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
testq %rsi, %rsi
je 0x434c0
movq %rdi, %r15
cmpl $0x0, 0x8(%rdi)
je 0x434c0
movq %rdx, %r14
movq %rsi, %rbx
movl %ecx, %r13d
testl %ecx, %ecx
je 0x433bf
leaq (%r14,%r13), %rax
cmpq 0x10(%r15), %rax
jbe 0x433bf
xorl %eax, %eax
jmp 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/VertexBuffer.cpp |
sf::VertexBuffer::operator=(sf::VertexBuffer const&) | VertexBuffer& VertexBuffer::operator =(const VertexBuffer& right)
{
VertexBuffer temp(right);
swap(temp);
return *this;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x42cd4
movq 0x10(%rbx), %rax
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%r14)
movl 0x8(%rbx), %eax
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rbx)
movl %eax, 0x8(%r14)
movl 0x18(%rbx), %eax
movl 0x18(%r14), %ec... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/VertexBuffer.cpp |
sf::priv::RenderTextureImplFBO::RenderTextureImplFBO() | RenderTextureImplFBO::RenderTextureImplFBO() :
m_depthStencilBuffer(0),
m_colorBuffer (0),
m_width (0),
m_height (0),
m_context (NULL),
m_textureId (0),
m_multisample (false),
m_stencil (false)
{
Lock lock(mutex);
// Register the context destructio... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xe830f(%rip), %rax # 0x12b958
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x1ebc8
leaq 0xe829c(%rip), %rax # 0x12b8f8
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x10(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%rbx)
movq %rcx, 0x18... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::priv::RenderTextureImplFBO::~RenderTextureImplFBO() | RenderTextureImplFBO::~RenderTextureImplFBO()
{
TransientContextLock contextLock;
Lock lock(mutex);
// Remove the frame buffer mapping from the set of all active mappings
frameBuffers.erase(&m_frameBuffers);
frameBuffers.erase(&m_multisampleFrameBuffers);
// Destroy the color buffer
if (m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xe80b4(%rip), %rax # 0x12b8f8
movq %rax, (%rdi)
leaq 0x7(%rsp), %rdi
callq 0x1ebe4
leaq 0xeb890(%rip), %rsi # 0x12f0e8
leaq 0x20(%rsp), %rdi
callq 0x225c4
leaq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14,... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
(anonymous namespace)::destroyStaleFBOs() | void destroyStaleFBOs()
{
sf::Uint64 contextId = sf::Context::getActiveContextId();
for (std::set<std::pair<sf::Uint64, unsigned int> >::iterator iter = staleFrameBuffers.begin(); iter != staleFrameBuffers.end();)
{
if (iter->first == contextId)
{
GLu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1d366
movq 0xeb691(%rip), %r14 # 0x12f0d0
leaq 0xeb67a(%rip), %r12 # 0x12f0c0
cmpq %r12, %r14
je 0x43abc
movq %rax, %rbx
leaq 0x9db96(%rip), %r13 # 0xe15eb
leaq 0xeb65c(%rip), %rbp # 0x12f0b8
cmpq %rbx, 0x20(%r14)
jne 0... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::priv::RenderTextureImplFBO::~RenderTextureImplFBO() | RenderTextureImplFBO::~RenderTextureImplFBO()
{
TransientContextLock contextLock;
Lock lock(mutex);
// Remove the frame buffer mapping from the set of all active mappings
frameBuffers.erase(&m_frameBuffers);
frameBuffers.erase(&m_multisampleFrameBuffers);
// Destroy the color buffer
if (m... | pushq %rbx
movq %rdi, %rbx
callq 0x4382c
movl $0x88, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xc940
nop
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::priv::RenderTextureImplFBO::getMaximumAntialiasingLevel() | unsigned int RenderTextureImplFBO::getMaximumAntialiasingLevel()
{
TransientContextLock lock;
GLint samples = 0;
#ifndef SFML_OPENGL_ES
glCheck(glGetIntegerv(GLEXT_GL_MAX_SAMPLES, &samples));
#endif
return static_cast<unsigned int>(samples);
} | pushq %rbx
subq $0x10, %rsp
leaq 0xb(%rsp), %rdi
callq 0x1ebe4
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movl $0x8d57, %edi # imm = 0x8D57
callq 0xc8c0
leaq 0x9d1b3(%rip), %rdi # 0xe0d0a
leaq 0x9d29a(%rip), %rdx # 0xe0df8
movl $0xc5, %esi
callq 0x452f8
movl 0xc(%rsp), %ebx
leaq 0xb(%rsp), %rdi
callq 0x1e... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::priv::RenderTextureImplFBO::create(unsigned int, unsigned int, unsigned int, sf::ContextSettings const&) | bool RenderTextureImplFBO::create(unsigned int width, unsigned int height, unsigned int textureId, const ContextSettings& settings)
{
// Store the dimensions
m_width = width;
m_height = height;
{
TransientContextLock lock;
// Make sure that extensions are initialized
priv::ensu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, 0x70(%rdi)
movl %edx, 0x74(%rdi)
leaq 0xf(%rsp), %rdi
callq 0x1ebe4
callq 0x45754
movl 0x8(%r12), %eax
testl %eax, %eax
je 0x43c18
leaq 0xeaf85(%... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::priv::RenderTextureImplFBO::createFrameBuffer() | bool RenderTextureImplFBO::createFrameBuffer()
{
// Create the framebuffer object
GLuint frameBuffer = 0;
glCheck(GLEXT_glGenFramebuffers(1, &frameBuffer));
if (!frameBuffer)
{
err() << "Impossible to create render texture (failed to create the frame buffer object)" << std::endl;
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
movl $0x0, (%r14)
leaq 0xead1c(%rip), %r13 # 0x12f000
movl $0x1, %edi
movq %r14, %rsi
callq *(%r13)
leaq 0x9ca13(%rip), %rdi # 0xe0d0a
leaq 0x9d090(%rip), %rdx # 0xe138e
movl $0x193, %esi... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::priv::RenderTextureImplFBO::activate(bool) | bool RenderTextureImplFBO::activate(bool active)
{
// Unbind the FBO if requested
if (!active)
{
glCheck(GLEXT_glBindFramebuffer(GLEXT_GL_FRAMEBUFFER, 0));
return true;
}
Uint64 contextId = Context::getActiveContextId();
// In the odd case we have to activate and there is no ac... | pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x44850
movq %rdi, %rbx
callq 0x1d366
testq %rax, %rax
jne 0x447cf
cmpq $0x0, 0x78(%rbx)
jne 0x447b3
movl $0x8, %edi
callq 0xc910
movq %rax, %r14
movq %rax, %rdi
callq 0x1d2b8
movq %r14, 0x78(%rbx)
movq 0x78(%rbx), %rdi
movl $0x1, %esi
callq 0x1d2f4
callq 0x1d366
tes... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::priv::RenderTextureImplFBO::updateTexture(unsigned int) | void RenderTextureImplFBO::updateTexture(unsigned int)
{
// If multisampling is enabled, we need to resolve by blitting
// from our FBO with multisample renderbuffer attachments
// to our FBO to which our target texture is attached
#ifndef SFML_OPENGL_ES
// In case of multisampling, make sure both FBO... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0x84(%rdi)
jne 0x44aff
movq %rdi, %rbx
cmpl $0x0, 0x70(%rdi)
je 0x44aff
cmpl $0x0, 0x74(%rbx)
je 0x44aff
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x18(%rax)
testb %al, %al
je 0x44aff
callq 0x1d366
movq %rax, %r14
leaq 0xea71e(%rip), %rsi #... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTextureImplFBO.cpp |
sf::BlendMode::BlendMode(sf::BlendMode::Factor, sf::BlendMode::Factor, sf::BlendMode::Equation, sf::BlendMode::Factor, sf::BlendMode::Factor, sf::BlendMode::Equation) | BlendMode::BlendMode(Factor colorSourceFactor, Factor colorDestinationFactor,
Equation colorBlendEquation, Factor alphaSourceFactor,
Factor alphaDestinationFactor, Equation alphaBlendEquation) :
colorSrcFactor(colorSourceFactor),
colorDstFactor(colorDestinationFactor),
colorEqu... | movl 0x8(%rsp), %eax
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
movl %eax, 0x14(%rdi)
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/BlendMode.cpp |
sf::operator==(sf::BlendMode const&, sf::BlendMode const&) | bool operator ==(const BlendMode& left, const BlendMode& right)
{
return (left.colorSrcFactor == right.colorSrcFactor) &&
(left.colorDstFactor == right.colorDstFactor) &&
(left.colorEquation == right.colorEquation) &&
(left.alphaSrcFactor == right.alphaSrcFactor) &&
(le... | movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
movq 0x10(%rdi), %xmm0
movq 0x10(%rsi), %xmm2
pcmpeqb %xmm0, %xmm2
pand %xmm1, %xmm2
pmovmskb %xmm2, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
sete %al
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/BlendMode.cpp |
sf::priv::copyMatrix(sf::Transform const&, sf::priv::Matrix<3ul, 3ul>&) | void copyMatrix(const Transform& source, Matrix<3, 3>& dest)
{
const float* from = source.getMatrix(); // 4x4
float* to = dest.array; // 3x3
// Use only left-upper 3x3 block (for a 2D transform)
to[0] = from[ 0]; to[1] = from[ 1]; to[2] = from[ 3];
to[3] = fr... | pushq %rbx
movq %rsi, %rbx
callq 0x40310
movss (%rax), %xmm0
movss %xmm0, (%rbx)
movss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rbx)
movss 0xc(%rax), %xmm0
movss %xmm0, 0x8(%rbx)
movss 0x10(%rax), %xmm0
movss %xmm0, 0xc(%rbx)
movss 0x14(%rax), %xmm0
movss %xmm0, 0x10(%rbx)
movss 0x1c(%rax), %xmm0
movss %xmm0, 0x14(%rbx)
movs... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/Glsl.cpp |
sf::priv::glCheckError(char const*, unsigned int, char const*) | void glCheckError(const char* file, unsigned int line, const char* expression)
{
// Get the last error
GLenum errorCode = glGetError();
if (errorCode != GL_NO_ERROR)
{
std::string fileString = file;
std::string error = "Unknown error";
std::string description = "No description"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0xc460
testl %eax, %eax
je 0x456bf
movl %eax, %r14d
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
callq 0xfd40
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9c748(%... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLCheck.cpp |
sf::priv::ensureExtensionsInit() | void ensureExtensionsInit()
{
#if !defined(SFML_OPENGL_ES)
static bool initialized = false;
if (!initialized)
{
initialized = true;
sfogl_LoadFunctions();
// Retrieve the context version number
int majorVersion = 0;
int minorVersion = 0;
// Try the new way ... | cmpb $0x0, 0xe9995(%rip) # 0x12f0f0
jne 0x4587f
pushq %rbx
subq $0x10, %rsp
movb $0x1, 0xe9983(%rip) # 0x12f0f0
callq 0x4150c
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
leaq 0xc(%rsp), %rbx
movl %eax, (%rbx)
movl $0x821b, %edi # imm = 0x821B
callq 0xc8c0
movl $0x821c, %edi # imm ... | /johnor[P]n_e_s_vis/build_O1/_deps/sfml-src/src/SFML/Graphics/GLExtensions.cpp |
ImGui::SFML::Init(sf::RenderWindow&, bool) | bool Init(sf::RenderWindow& window, bool loadDefaultFont) {
return Init(window, window, loadDefaultFont);
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addq $0x30, %rdi
movq 0x30(%r14), %rax
callq *0x10(%rax)
movl %eax, %ecx
cvtsi2ss %rcx, %xmm0
shrq $0x20, %rax
movq %rsp, %rsi
movss %xmm0, (%rsi)
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x4(%rsi)
movq %r14, %rdi
movl %ebx, %edx
callq 0x45959... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-sfml-src/imgui-SFML.cpp |
ImGui::SFML::Init(sf::Window&, sf::RenderTarget&, bool) | bool Init(sf::Window& window, sf::RenderTarget& target, bool loadDefaultFont) {
return Init(window, static_cast<sf::Vector2f>(target.getSize()), loadDefaultFont);
} | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movl %eax, %ecx
cvtsi2ss %rcx, %xmm0
shrq $0x20, %rax
movq %rsp, %rsi
movss %xmm0, (%rsi)
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x4(%rsi)
movq %r14, %rdi
movl %ebx, %edx
callq 0x45959
addq... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-sfml-src/imgui-SFML.cpp |
ImGui::SFML::Init(sf::Window&, sf::Vector2<float> const&, bool) | bool Init(sf::Window& window, const sf::Vector2f& displaySize, bool loadDefaultFont) {
#if __cplusplus < 201103L // runtime assert when using earlier than C++11 as no
// static_assert support
assert(sizeof(GLuint) <= sizeof(ImTextureID)); // ImTextureID is not large enough to fit
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
movl $0x120, %edi # imm = 0x120
callq 0xc910
movq %rax, %r13
movq %rax, %r15
leaq 0x10(%rax), %r12
movq %r12, %rdi
callq 0x3e04c
movq $0x0, 0x48(%r15)
movabsq $0x10000... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-sfml-src/imgui-SFML.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.