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

help-circle


  • For me the legacy nVidia driver put on the AUR is a no-go. Even before that, non-fiber internet added friction to updating especially when I forgot about it for a while (or when manual intervention is needed).

    I installed Void Linux on an old machine, I think updating might be more forgiving but the packaging system isn’t quite as good* and for some things I’d have to rely on appimages (I don’t want redundancy from Flatpak etc).

    Tumbleweed/Slowroll might be a better answer if I didn’t hate Patterns.

    * after adding some applications, already had to manually install missing dependencies, optional dependencies is also not handled




  • 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.



  • I almost got void fully installed and working
    I just wanted my new replacement laptop up
    I gave up 🥹

    Did you use the XFCE version? I did so (XFCE musl*) on an old machine, had a bit of trouble with the partitioning at first (had to try the live image a second time because new changes weren’t working) but ultimately worked fine. Seems to run fine, then again I wanted XFCE anyway. Install octoxbps and you can use that for installing/updating software as well.

    Though post-install I did notice some dependencies being missing when installing some software, and packaging seems weak (like no optional dependencies like Arch has). So I haven’t committed to it on my main machine**, though I guess I can test it to see Void’s long-term updating experience (though the live image being from ~6-months ago probably says enough).

    * because I am actually interested in this for compilation, and it actually is a use-case for an old machine

    ** outdated Arch… a bit of friction with my non-fiber internet, legacy GPU (1050Ti) drivers on AUR is a no-go for me


  • I’ve used my current install for at least that long (going back further with Antergos) and you’re correct about non-rolling options… I definitely would’ve had more pain with system upgrades and PPAs etc in those years.

    That said, I think the Tamagotchi comparison probably makes sense in a way if it “dies” you probably did something “wrong” as on-paper it’s also not difficult to maintain a digital pet either.

    I’m using an outdated system, it’s on three strikes:

    1. Slow, shared internet for me. This adds friction to updates, and when I don’t update as frequently as Arch expects this is the breakage you won’t see.

    2. I hate that updating today vs days-from-now might yield drastically different results. Admittedly the actual problem with my last few updates is that the reason-I-updated issues persisted.

    3. The AUR is the biggest reason to use Arch. But use the AUR very carefully and not for system dependencies! Your graphics card is now legacy, so we put the driver on the AUR* ;)


    Though I don’t think these sort of problems are unfixable**, and other rolling distros probably do fix some of them but may also not have as good of a packaging system as Arch.

    For instance I’m trying Void Linux on an old machine and have already ran into 2 (non-default) applications missing dependencies (which might be an issue with package maintainers, but also Void doesn’t seem to track optional dependencies).

    Tumbleweed/Slowroll would probably be a better fit for me, if not for Patterns.

    * also if you update without switching, blank screen for you

    ** internet+GPU are also material problems as well, but those cannot get fixed today and probably will not be fixed next month either



  • 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


  • I don’t know much about that universe, so I’d probably choose the escapism option (perma-VR*, chem synthesis). Realistically, probably dumpster parts or some bartered hand-me-down stuff. Sidestepping universe, If I were lucky I’d get one-o’them Jameson-types! (or brain-in-a-tachikoma)

    Genre aside, I’d go for something more organic (maybe something closer to Farscape). Less upkeep, more microbiomes/symbiosis. Even for the ‘cybernetic’ part of cyborg, there’s less interest if whatever I could be hooked into isn’t an extension of my nervous system in some way.

    * not to condone current VR, given price and limited content. I’ve barely used a relative’s dusty headset because I couldn’t install anything (even if I made it myself) because no Facebook


  • 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.