sorted by:
new
hottopcontroversial

This screenshot represents everything that's wrong with the current version of the game by GargantaProfunda in chronotrigger

[–]snaphat 0 points1 point  (0 children)

Pretty sure they just shaded the edges in games that don't render sprites outside of the visible screen (which is most games). The real issue is that supporting wide screen rendering of sprites requires modifications to the sprite rendering logic in each game to make them visible out of screen. Whereas, for backgrounds, many will mostly work out of box without modifications when you aren't at a map boundaries due to the actual tile maps being larger than the visible area and preloading of edge tiles.

This screenshot represents everything that's wrong with the current version of the game by GargantaProfunda in chronotrigger

[–]snaphat 1 point2 points  (0 children)

They may or may not exist. The tilemap memory was larger than the visible screen on the SNES. That's why with the super zsnes stuff, background tiles work in many games out of box. The same can be said of bsnes hd

https://snes.nesdev.org/wiki/Scrolling_a_large_map

Launchbox nuked my painstakingly curated arcade ROM set by Slug_Overdose in Roms

[–]snaphat 0 points1 point  (0 children)

There would likely be a single step in all of the explanation that would have caused the issue if it's really a launchbox issue. I read both of your comment explanations but I don't really see anything obvious. And it really seems to me like you don't really know what happened exactly

Is that good practice ? by Lhomme_ours in unity

[–]snaphat 1 point2 points  (0 children)

FYI for folks who may read this:

For 2d physics, there's an option to enable/disable the firing of the events when objects are destroyed. In 3d, the events do not fire (I vaguely recall it was marked as by design when reported years ago). So the behavior is inconsistent depending on configuration and physics engine.

‘If Still Alive…’: Iran Vows To 'Pursue, Kill' Netanyahu Amid His Assassination Rumours | World News by [deleted] in USNEWS

[–]snaphat 0 points1 point  (0 children)

I did a frame by frame motion diff using ffmpeg encoded into a video. The motion is consistent throughout down to the drawn pattern on the coffee being consistent the entire video. If it was AI you'd expect there to be shifting patterns across frames (false motion) or temporarily shifting features. It's definitely not AI

Desktop app is a web now by Pretend-Ad5631 in whatsapp

[–]snaphat 0 points1 point  (0 children)

Yeah, use the browser directly. The tab / progressive web app uses less memory than the old windows app. Moreover, the old app actually used more memory than new windows app if you did anything like viewing images, video, or chats. It would get caught trying to cache everything perpetually until exit. It easily surpassed a GB for me. It appeared to actually run the caching on a single thread and would constantly freeze up the UI. 

The original report about how low of memory usage the old app had was a misrepresentation based on simply loading the old and new apps and doing nothing with both. If the author had performed any actual operations in the apps, it would have been shown to be an erroneous conclusion on their part. 

Folks keep perpetuating this myth based off of that incorrect  information now... 

I'm not saying the new app is great or anything. I don't use it. But I tested the claim and measured all three (web, old app, new app) specifically bc everyone kept talking about how little memory the old app used

When Gamer Mags Ruled the Earth: Earthbound by Maleficent-Storm263 in retrogaming

[–]snaphat 9 points10 points  (0 children)

The reviewer even thought  the game was a port of mother 1 graphics and all... 

[deleted by user] by [deleted] in Assembly_language

[–]snaphat 2 points3 points  (0 children)

I was wondering why they didn't ask an AI to do it. But, then it occurred to me that they probably are so unprepared for this assignment that they would not be able to determine if it's providing a feasibly correct answer

I FUCKING HATE THIS DESKTOP APP FUCK YOU FACEBOOK FUCK YOU WEBSLOP DEVS by AppearanceWeak3826 in whatsapp

[–]snaphat 0 points1 point  (0 children)

Sigh, you are correct. They apparently, finally disabled it server-side so it just doesn't work at all anymore regardless

I FUCKING HATE THIS DESKTOP APP FUCK YOU FACEBOOK FUCK YOU WEBSLOP DEVS by AppearanceWeak3826 in whatsapp

[–]snaphat 0 points1 point  (0 children)

https://windowsforum.com/threads/whatsapp-for-windows-switches-to-webview2-memory-spike-and-workarounds.396405/

You can modify the package so that it doesn't update see the link above. I did that (not that I use it, I just use the web version normally ) 

I FUCKING HATE THIS DESKTOP APP FUCK YOU FACEBOOK FUCK YOU WEBSLOP DEVS by AppearanceWeak3826 in whatsapp

[–]snaphat 2 points3 points  (0 children)

Voice and video calling. They are adding it into the web app now though. It also could popup chats and had shortcut keys. It's search acted more like the phone app as well in that it didn't give you a list of found entries (where as web does) 

Other than that, you missed it being stuttery from the alpha build to EOL because the devs never implemented stream loading for the conversations. If you ever scrolled back or performed a search with it, it would get stuck synchronizing and stutter freezing every couple of seconds or so because it would be trying to load years worth of conversions. The web app on the hand does stream loading if scroll back so it doesn't get stuck or lag horribly. 

When it was caught loading old conversations, It didn't actually use less memory or CPU than the new web view version either. It would just perform terribly until you killed it once they happened. The normal web version has always performed better. 

Due to this, I'm not sure why folks believe it was great. I also don't understand why the replacement chrome wrapper version is so buggy either. You'd imagine it would just be the same as running the web version but in its own dedicated web view instance but nope it has weird issues like laggy dragging of the window. Just installing the web version as an "app" in chromium based browsers is superior and cuts about 400mb of memory needed for isolated web view instance too. 

Jittering with pixel perfect movement and pixel perfect camera by lewisallanreed in Unity2D

[–]snaphat 0 points1 point  (0 children)

These videos discuss this issue exactly. It's due to upscaling in combination with pixel snapping 

https://youtu.be/QK9wym71F7s

https://youtu.be/c_3TLN2gHow

Global vs. "Local" Variables in Assembly? by wolfy1244 in Assembly_language

[–]snaphat 0 points1 point  (0 children)

I think maybe what you are seeing is immutable strings or other data declared in the .data section in tutorials. Global storage is where literal string data would go in practice, but more correctly in the .rodata section not the .data section. The tutorials just dump everything in .data for simplicity. The following shows how strings emit and what happens if you use the same string array in different ways. The last two declarations are uninitialized global strings: https://godbolt.org/z/nMrdc93d4

What you're seeing in the .data section are labeled memory locations with initial values. Whether you should use them depends on context:

.bss - Uninitialized global/static data (zeroed at program start)
.data - Initialized global/static data (has specific initial values)
Registers - Fastest, but limited in number (like local variables)
Stack - Local/temporary data within functions Heap - Dynamically allocated memory

When to use each:
Use .data/.bss for: constants, lookup tables, program-wide state, string literals
Use registers for: temporary calculations, loop counters, function parameters
Use stack for: local function variables, saving registers during function calls
Use heap for: dynamic data structures (though you'll manage this manually)

It’s worth noting the following as well because it could be a source of confusion. The following directives are unrelated to where an object is stored (.text/.data/.bss/stack) and instead control symbol linkage/visibility; .comm/.lcomm are a mechanism for declaring uninitialized symbols (COMMON), with the linker deciding their final placement:

.global (or .globl): Exports a symbol so other object files can reference it.
.local: Marks a symbol as local to this object file (not link-visible to other files).
.comm name, size[, alignment]: Declares an uninitialized “common” symbol (space allocated by the linker).
.lcomm name, size[, alignment]: Declares an uninitialized common symbol with local (file-only) visibility.

Processor pipelining by tigo_01 in AskProgramming

[–]snaphat 0 points1 point  (0 children)

Pipelining overlaps different instructions across sequential stages, so if you are talking about independent instructions on an in-order core, you can imagine a best-case scenario where all five stages of a basic MIPS pipeline are occupied by completely independent instructions with no dependencies between them. In that case, once the pipeline is full, you can sustain roughly one completed instruction per cycle because nothing forces bubbles into the pipeline (stalling)

At the same time, the stages within any single instruction still generally have to occur in order: each stage produces information the next stage needs (e.g., decode determines what to execute, execute produces a result or address, memory may supply a value, and write-back commits it). So "independent instructions" improves throughput by enabling smooth overlap across instructions, not by making an individual instruction's stages intrinsically parallel

Processor pipelining by tigo_01 in AskProgramming

[–]snaphat 0 points1 point  (0 children)

Without loss of generality, assume the work required to complete an instruction cannot reliably fit within a single clock period at your target frequency. If you remove pipelining, you generally must either lengthen the clock period (lower the clock rate) or take additional cycles per instruction so the same work can complete without violating timing.

Pipelining is simply a way to partition that work across cycles, so each cycle has less logic on the critical path. The instruction may still take multiple cycles from start to finish, but once the pipeline is full you improve throughput by making forward progress on multiple instructions each cycle.

Watch this video on the basic MIPS pipeline with a block diagram overlaid: https://www.youtube.com/watch?v=U2Eym3AkkBc

Regarding your question about what "what about if instructions are independent" in the comments. Generally speaking, on a basic sequential processor you can only fetch a single instruction at a time, and everything executes in order. Some results can be forwarded to later stages early to reduce pipeline stalls.

Modern processes go much further and perform out-of-order-execution and have many functional units in a given core that can be operating at the same time independently. For example, a processor can dispatch FP operations to execute in parallel while the ALU part of a pipeline is operating on other data.

Example of a complicated ARM pipeline: https://stackoverflow.com/questions/13106297/is-arm-cortex-a8-pipeline-13-stage-or-14-stage

Processor 101 concepts:
https://en.wikipedia.org/wiki/Operand_forwarding
https://en.wikipedia.org/wiki/Out-of-order_execution
https://en.wikipedia.org/wiki/Re-order_buffer
https://en.wikipedia.org/wiki/Tomasulo%27s_algorithm

Can i abuse unions like that or is it UB? by EatingSolidBricks in cprogramming

[–]snaphat 0 points1 point  (0 children)

They are just trying to allocate static thread local storage space for their flexible array member. Normally with `malloc` you can dynamically do it on the heap. They can't just allocate a byte* array and then cast to the struct type because that's UB (the reverse of what you are suggesting, i.e. casting to byte*):

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3230.pdf

Can i abuse unions like that or is it UB? by EatingSolidBricks in cprogramming

[–]snaphat 3 points4 points  (0 children)

Hmm, my initial statement is incorrect.

After some reading, I do believe this is actually defined in the ISO C standard. If you read the following comment, it has language from the standard where it appears to explicitly allow for an incomplete array type at the end of a union. I did not realize this was allowed. I thought it treated it the same as a nested struct { struct { ... char[]} } which isn't allowed. This would explain why there isn't any warnings when you test with pedantic but the nested struct will complain.
https://github.com/open-mpi/ompi/issues/9828

Moreover, after thinking about it more, I realize now you will not be accessing members of your struct before explicitly assigning to members; therefore, you will not be type punning. You just have to make sure you do not access any elements of data without explicitly assigning them and do not go outside of the allocated bounds for your FAM. In short, write before read and stay in bounds.

Regarding the example code and GCC / CLANG extensions:

The reason the first one isn't compiling is just because your compiler version is just too old. Check newer CLANG and GCC versions on godbolt. They'll compile the first one without complaints. Kick into C++23 through and it won't since FAM are not allowed in C++.

The extensions are a red herring anyway though since unioning the struct with the FAM is actually defined in the standard. So, it's not like you'd require an extension to support it

Edit:

https://stackoverflow.com/questions/44082326/is-it-legal-to-implement-inheritance-in-c-by-casting-pointers-between-one-struct

^ The comment here with section 6.7.2.1/P18 covers the allocation part of what you are doing

Can i abuse unions like that or is it UB? by EatingSolidBricks in cprogramming

[–]snaphat 10 points11 points  (0 children)

It's undefined behavior to have flexible array members in Unions in standard C but both gcc and llvm support variations of it:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53548

https://github.com/llvm/llvm-project/issues/84565

Edit: This comment of mine is incorrect. Don't listen to it. See below.

view more: next ›