• 3 Posts
  • 90 Comments
Joined 2 years ago
cake
Cake day: November 20th, 2024

help-circle
  • I’ve done similar things with pan-roasted vegetables (some mix* of zucchini, onion, carrot, celery, red bell or jalapeno, mushroom (roughly that order for most-to-least used) lid is used on-and-off). I’ll throw pepperoni bits in at the end to brown a bit.

    If I’m lazy I’ll just add sauce after plated, sometimes cheese in the pan (not long enough to cause a mess), or throw it all in a tortilla and cook it again in an old electric grill (easier to dip it in sauce instead, too).

    A few times I’ve pre-soaked pasta noodles in a 28oz bowl, microwaved them, drain then brown the noodles a bit in the pan with everything else and transfer it back to the noodle bowl and layer in the other pizza ingredients (w/further microwaving, plate-as-lid).

    * usually 2-3 things, though I’ve done just zucchini+sauce before


  • You are right about a few things, though the key is that Raylib is what’s creating the polygon (after I parse the text file into a sequence) and ideally I don’t handle face/mesh creation myself (at low-level). Maybe eventually.

    what you mean by color index face hints

    For additional context on where faces are.

    I’ve mentioned vertex color (ideal as face colors), but I probably do want to handle a 3-digit-hex color palette with object-library-wide management.

    here's what I was thinking with verts no longer numbered (instead E for external, C for corner. even-odd might work better in some cases), index numbers as hints and for color

    Each arm would be its own color

    #values: matrix_xres matrix_yres target_size vert_num
    #IDEA, fails with heart as there is only 1 corner vertex
    32
    32
    160.0
    11
                                    
                   E                
                   1                
                                    
                                    
                                    
                                    
                                    
                                    
                                    
                                    
    E2         C       C         3E 
                                    
                                    
                   1                
                  2@3               
                  4 5               
             C           C          
                                    
                                    
                                    
                   C                
                                    
                                    
                                    
                                    
                                    
                                    
                                    
         4                    5     
        E                      E    
                                    
    
    

    The reason I’m thinking about this is that it would be better to have one way to define verts. triangle_strip can generally do more (shapes with no central point) than triangle_fan, though I think the star here is the sort-of-thing that a single triangle_strip cannot do. That, and with numbering it only allows 62 verts (0…9, a…z, A…Z), and is a bit clunky to iterate on. Numbering, especially with a strip, is also a lot more complex as you get more verts. If I got to the point of making my own editor*, I might abstract this away so the user only works with points.

    Use-in-code-wise I may have already solved fan-vs-strip with a function that just compares the values of the first few points to choose draw type, though I wasn’t confident in that as it’d require a lot more testing. Might be better to store that in an enum as well.

    * I wasn’t quite sure of using what I already made for anything more than a simple arcade-like game, so that sort of kills motivation, needing to do even more technical work just to get visible results.


  • That’s how it could work when it gets to 3D anyway (with face-corner vertex color which I might not always need) but that’d be a pain to define by hand and the format I have I don’t actually have a way to define the same point more than once as it’s on a text grid.

    for example, an oval

    Note: it appears round here, but it isn’t

    #values: matrix_xres matrix_yres target_size vert_num
    #vert pattern is cntrclckwse (related: replace 0 with @ for closed shape) or |/|/
    31
    15
    160.0
    9
                   1               
                                   
        2                     8    
                                   
                                   
                                   
                                   
    3              @              7
                                   
                                   
                                   
                                   
        4                     6    
                                   
                   5               
    
    

    Easier to edit in a text editor with syntax highlighting that marks spaces for a visible grid.
    My face hinting idea also doesn’t work with this shape due to orientation (would work as a more traditional octagon), it also seems to be more obvious/viable with a larger grid (looks right for a 32x32 star shape).



  • I have a couple of ideas bouncing around, but they might be too ambitious (plus harder that I use a less common language, often via bindings).

    The first is a lot of ideas for a mesh editor, but not sure where to start. Technically, I already started a while ago with a text-based* polygon format/loader for Raylib so if I had some (high-level) way to export that polygon to a 3D file (single/double-sided faces or extruded) that’d be the first step. However I never really used/continued what I made (2D) because of how windings (fan vs strip) are, not good** as you’d need to keep track of it during usage. Perhaps something else might be better, like p5js?

    The other is a frameless+floating X11 WM, and I’m similarly unsure of what I should use for drawing a title/titlebar and window buttons (and inset controls if possible). .xpm for bar/buttons is a maybe.

    * sparse (a rectangle is 4 numbers on an otherwise empty grid), not like traditional (filled) ASCII art

    ** maybe expecting winding from an unordered list of points is too much, but not sure there’s an easy way to cover windings for most situations. Color index (8-way) used as face hints, or similar (4-way?) for inside direction? Multiple origins for raycasts?



  • Somewhat true, but I also don’t think these cards actually fit that market with the prices especially for those stuck on PCIe3.0 hardware. Imagine buying a new pre-built for a decent sum of money and still being stuck with ~2016 (1050Ti/RX570 4GB) limitations. (even the 8GB version seems to perform just below the RTX 5050, which has lower MSRP but seems to be controversial due to the price)

    Maybe the market really is just this terrible, but it does seem like waste of sand territory. I do think this says more about how bloated (and “upgrade your PC” CEO says) games are, though.

    Makes me wonder if somebody could chop things down

    (downscaling and color quantization) and if it’d make enough difference to justify it, though that would take a lot of work/knowledge (to not look terrible) while already be in legal non-gray area* just like re-packs while also being as niche as Doom-2016 low-spec settings. Practically de-make territory.

    * As in you couldn’t legally distribute it even as a post-install texture pack (for games that support that). Maybe it could be done via a script, but this does not allow data saving, and would be really bad if you decide you don’t like the look (and I assume for something like Steam you’d have to be careful that it doesn’t re-download the original textures).


    EDIT: I’m seeing some sites say it’s x16, but the wccftech article says both 8GB and 4GB models have PCIe 5.0 x8 (so it could be an issue for even those on PCIe 4.0 motherboards). The 4GB model also has a half memory bus though I don’t know how much that matters especially with differing memory speeds/generations.

    Also seems like it needs a power cable still, but maybe the 4GB version is low enough power that a pcie-power-only version could exist.



  • OP posted to this sub with an article about void 17 days ago. OOP, sure maybe.

    I’m trying Void on old hardware and it feels pretty usable. Package availability still an issue*. I’ve also noticed some dependencies not getting added (git not included with programming lang that needs it for its package manager, installed archive manager engrampa and it couldn’t actually open zips until I added another package for that). I’ll probably keep this on my old machine just for testing musl compilation.

    * appimages might help, other solutions with redundancy not so much with extra downloading


  • Same here, much too ambitious/low-level for me. I haven’t done enough though, TBH (currently stalled, for a few reasons). I did complete my last project though (~150 LoC minesweeper clone, Godot+bindings, no UI except win/lose screen, and I did simplify and pick my features).

    some of my project ideas
    1. simplified X11 floating WM, clone of my current frameless XFWM window theme
      • First steps: rectangle (titlebar) above window contents that can drag the window, close button within the window contents
    2. simple 3D mesh editor+part/face colors (VC), 2D workflow with extrude/revolve, project palette management
      • First steps: hexy triangle mesh with faces that can be painted+deleted, manually place faces (think wooden pattern blocks), any depth (vase, multiple heights, multiple sides/parts, transform)
      • the sort of thing you could make wall decorations, mesh particles, chess pieces etc
    3. gridmap editor supporting multiple sizes, semi-modular room creation
      • First steps: cuboid cell placement+space reservation, single-layer auto-tile (made of at least 3 cell types, though I also have an outer corner for hallway junctions)

    This assumes I can figure out how to do these at high-level (using libraries, not writing mesh stuff completely from scratch).


    EDIT, an extra:

    1. At one point, I wanted to make something to take analog input from a gamepad trigger and turn it into pen pressure (in one hand, position from mouse in other hand). Some people have looked into this for sc-controller but it didn’t seem viable (input type mixing might be an issue). I wonder how much just an evdev rule or two could do.

    Even those might be more-than-a-few completed simple projects away for me (if I can get that far), though.

    I was going to say voxel stuff isn’t such a bad idea, though when searching I did find a voxel editor with smoothing which is the one thing I’d want there (not quite sure about it using ASCII).

    The 1.44MB thing has made me think about stuff like Raylib again, though a while back I actually made a toy-like polygon text format+loader but wasn’t quite happy as it’s sort of in catch-22 territory (usage complicated by 2 polygon types w/different capabilities+windings, if that weren’t an issue an editor still might be nice).

    I likely will stay with Godot for 3D, moving on to something simpler (like Raylib) especially when I have a set of models that look good unshaded.





  • With the language I use I could benefit (interop) though I like the abstraction because I’m doing everything on my own (programming/gamedev, 3D art, sounds, workflow, ideas) and don’t practice those enough as-is! At this point I just need to do anything.

    Stalled motivation because I can’t even share my last project (that I actually finished!) due to system issues I also have to fix/sidestep (would be a bit easier with a different GPU, no guarantee I’ll get one for a price I find fair).

    Aside from getting things in order, I might look at a blue programming (assuming it is C) book with a cool cover I remember my dad having (if he ever finds it). Fuzzy memory means I can’t find it online, so no idea if it even holds up.



  • The reason anyone thinks it’s slow is that in the real world, people still ship* Python scripts/projects that don’t offload their performance-sensitive code to faster solutions.

    Acting as glue isn’t unknown to anyone looking into Python either, problem being there are multiple different solutions that each have their own benefits/drawbacks that will differ based on the use-case. Fine if you can lean on an existing library, more complicated if you actually need to write the performance-sensitive code.

    Similar to @Chais@sh.itjust.works, plus newer compile-to-C/C++/JS languages offer a lot of what Python does (glue, whitespace, style) plus more stuff like UFCS.

    My preference is nim-lang, it has stuff like for i in 1..17: (or something like
    for h in 0.uint8..<height:. Typing is a thing but doesn’t stop me, so either not a big hurdle or there’s something with my brain that makes it fine despite issues with other languages/styles). Nimscript is an option, and I like Clang with opt:size for an efficient testing option (Bellard’s TCC was an even better option for quick iteration in the past, not exactly supported now (as of 2023) though. Might work for other languages).

    * my last experience with this was a piano thing (soundfonts for MIDI keyboard) that had choppy audio when played too quickly and would crash my Raspberry Pi 2B. The issue was closed as not planned.





  • Keeping it simple, have you tried to solve something on your own? Even in the case here, making something similar but not with the exact code from the book, but a “close enough” solution. And putting your own spin on it that makes sense for your structure.

    I am not exactly a beginner (nor exactly experienced), but I had this moment with a minesweeper clone. I wasn’t quite sure on structure with first attempt. I waited a while and eventually figured out how to actually start and complete it.


  • I honestly wouldn’t be too concerned about the space used by Flatpak dependencies

    Space is a concern but not the concern, it’s about download time. It’s a considerable price of admission (worse with updates, though maybe not so anymore with legacy). I actually tried Flatpak at one point for Krita, and that is part of why I switched back to native.

    You won’t get the most bleeding-edge performance features
    EndeavourOS has been noticeably snappier

    Yeah, I’m more worried about backtracking from my current setup (a bit more than half-a-year out-of-date but still newer kernel than Debian stable EDIT: correction). Particularly snappiness, I expect optimizations are a big part of that (CPU is Ryzen 2700, might be more important for that).