i actually ported msvc std source to c# with a `Ref<T>` helper lol

i actually ported msvc std source to c# with a `Ref ` helper lol

TechPizza · 2023-04-08T19:01:52.748Z

i actually ported msvc std source to c# with a `Ref ` helper lol

T

TechPizzaOP•4/8/23, 7:02 PM

it was basically a

ref

ref

that acted as a pointer

TTechPizza i actually ported msvc std source to c# with a `Ref<T>` helper lol

P

Perksey•4/8/23, 7:18 PM

Yeah this is basically what I’m thinking, but I just need to figure out how we can have a Ref-like struct in a non-ref struct

P

Perksey•4/8/23, 7:19 PM

otherwise you can’t have Ptr<VkBaseOutStructure> and other common patterns

FFurball dxvk exists but idk if the developer experience on linux would be great

L

Lyris the Kitori•4/8/23, 8:17 PM

you have access to renderdoc and a debugger, so it's really workable

PPerksey you awoken the era of graphics i've been trying to pretend doesn't exist 😂

L

Lyris the Kitori•4/8/23, 9:11 PM

https://github.com/Furball-Engine/Furball.Vixie/blob/master/Furball.Vixie.Backends.OpenGL/FixedFunctionOpenGLRenderer.cs
when

GitHub

Furball.Vixie/FixedFunctionOpenGLRenderer.cs at master · Furball-En...

A Multi API Renderer specifically designed to be integrated into Furball, aswell as providing good Hardware support - Furball.Vixie/FixedFunctionOpenGLRenderer.cs at master · Furball-Engine/Furbal...

L

Lyris the Kitori•4/8/23, 9:13 PM

if you think about it FFP is better than modern OpenGL as it has display lists

L

Lyris the Kitori•4/8/23, 9:13 PM

so its basically vulkan with command lists

P

Perksey•4/8/23, 9:13 PM

NO BAD

PPerksey NO BAD

L

Lyris the Kitori•4/8/23, 9:13 PM

OKAY BUT DISPLAY LISTS IN MODERN OPENGL WOULD BE SO NICE

L

Lyris the Kitori•4/8/23, 9:13 PM

i know theres nv_command_list but its nv only

L

Lyris the Kitori•4/8/23, 9:14 PM

FFP OpenGL does have SOME things going for it

L

Lyris the Kitori•4/8/23, 9:14 PM

the ability to disconnect recording draw commands from execution is something that OpenGL should have kept

T

TechPizzaOP•4/8/23, 9:14 PM

funnily enough, recorded display lists on nvidia in legacygl seem pretty good

T

TechPizzaOP•4/8/23, 9:15 PM

the only problem is that conditional rendering is a no-go

L

Lyris the Kitori•4/8/23, 9:15 PM

yeah on my ol 1050ti my FFP code was shockingly fast

L

Lyris the Kitori•4/8/23, 9:15 PM

like

L

Lyris the Kitori•4/8/23, 9:15 PM

it was 10x slower

L

Lyris the Kitori•4/8/23, 9:15 PM

but

L

Lyris the Kitori•4/8/23, 9:15 PM

thats still

L

Lyris the Kitori•4/8/23, 9:15 PM

really fast

L

Lyris the Kitori•4/8/23, 9:15 PM

with my engine

T

TechPizzaOP•4/8/23, 9:15 PM

i mean, take minecraft beta for example. it recorded chunks to display lists i think

L

Lyris the Kitori•4/8/23, 9:16 PM

yeah i think it did

P

Perksey•4/8/23, 9:16 PM

it's weird that amd hasn't tried implementing nv_command_list

L

Lyris the Kitori•4/8/23, 9:16 PM

copyright maybe?

P

Perksey•4/8/23, 9:16 PM

they implemented WGL_NV_dx_interop

L

Lyris the Kitori•4/8/23, 9:16 PM

im shocked Mesa doesnt have it

L

Lyris the Kitori•4/8/23, 9:16 PM

nv_command_list is something i would expect Mesa to be able to do

L

Lyris the Kitori•4/8/23, 9:16 PM

OH i wonder if Zink has it

L

Lyris the Kitori•4/8/23, 9:16 PM

Zink would make sense to have it

L

Lyris the Kitori•4/8/23, 9:17 PM

id test but they still havent fixed whatever bug causes my engine to crash on Zink

P

Perksey•4/8/23, 9:17 PM

holy crap the nv_command_list spec is also extremely detailed

L

Lyris the Kitori•4/8/23, 9:17 PM

still

P

Perksey•4/8/23, 9:18 PM

although the way it's presented immediately makes it obvious why it isn't implemented

P

Perksey•4/8/23, 9:18 PM

engines can just do this

T

TechPizzaOP•4/8/23, 9:18 PM

veldrid moment

P

Perksey•4/8/23, 9:18 PM

        enum DrawCommandSequenceNV(enum mode, enum indexType, void *address, sizei size)
        {
          enum modeStrip;
          if      (mode == TRIANGLES)            modeStrip = TRIANGLE_STRIP;
          else if (mode == LINES)                modeStrip = LINE_STRIP;
          else if (mode == LINES_ADJACENCY)      modeStrip = LINE_STRIP_ADJACENCY;
          else if (mode == TRIANGLES_ADJACENCY)  modeStrip = TRIANGLE_STRIP_ADJACENCY;
          else if (mode == QUADS)                modeStrip = QUAD_STRIP;
          else    modeStrip = mode;

          enum modeSpecial;
          if      (mode == LINES)      modeSpecial = LINE_LOOP;
          else if (mode == TRIANGLES)  modeSpecial = TRIANGLE_FAN;
          else    modeSpecial = mode;

          void *current = address;
          
          while (current != (ubyte *)address + size) {
            uint    header  = *(uint*)current;

            switch( GetTokenType(header)){
            case TERMINATE_SEQUENCE_NV:
              {
                return indexType;
              }
              break;
            case NOP_COMMAND_NV:
            
              break;
            case DRAW_ELEMENTS_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(mode, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
            case DRAW_ARRAYS_COMMAND_NV:
              {
                DrawArraysCommandNV* cmd = (DrawArraysCommandNV*)current;
                DrawArrays(mode, cmd->first, cmd->count);
              }
              break;
            case DRAW_ELEMENTS_STRIP_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(modeStrip, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
...

        enum DrawCommandSequenceNV(enum mode, enum indexType, void *address, sizei size)
        {
          enum modeStrip;
          if      (mode == TRIANGLES)            modeStrip = TRIANGLE_STRIP;
          else if (mode == LINES)                modeStrip = LINE_STRIP;
          else if (mode == LINES_ADJACENCY)      modeStrip = LINE_STRIP_ADJACENCY;
          else if (mode == TRIANGLES_ADJACENCY)  modeStrip = TRIANGLE_STRIP_ADJACENCY;
          else if (mode == QUADS)                modeStrip = QUAD_STRIP;
          else    modeStrip = mode;

          enum modeSpecial;
          if      (mode == LINES)      modeSpecial = LINE_LOOP;
          else if (mode == TRIANGLES)  modeSpecial = TRIANGLE_FAN;
          else    modeSpecial = mode;

          void *current = address;
          
          while (current != (ubyte *)address + size) {
            uint    header  = *(uint*)current;

            switch( GetTokenType(header)){
            case TERMINATE_SEQUENCE_NV:
              {
                return indexType;
              }
              break;
            case NOP_COMMAND_NV:
            
              break;
            case DRAW_ELEMENTS_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(mode, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
            case DRAW_ARRAYS_COMMAND_NV:
              {
                DrawArraysCommandNV* cmd = (DrawArraysCommandNV*)current;
                DrawArrays(mode, cmd->first, cmd->count);
              }
              break;
            case DRAW_ELEMENTS_STRIP_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(modeStrip, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
...

        enum DrawCommandSequenceNV(enum mode, enum indexType, void *address, sizei size)
        {
          enum modeStrip;
          if      (mode == TRIANGLES)            modeStrip = TRIANGLE_STRIP;
          else if (mode == LINES)                modeStrip = LINE_STRIP;
          else if (mode == LINES_ADJACENCY)      modeStrip = LINE_STRIP_ADJACENCY;
          else if (mode == TRIANGLES_ADJACENCY)  modeStrip = TRIANGLE_STRIP_ADJACENCY;
          else if (mode == QUADS)                modeStrip = QUAD_STRIP;
          else    modeStrip = mode;

          enum modeSpecial;
          if      (mode == LINES)      modeSpecial = LINE_LOOP;
          else if (mode == TRIANGLES)  modeSpecial = TRIANGLE_FAN;
          else    modeSpecial = mode;

          void *current = address;
          
          while (current != (ubyte *)address + size) {
            uint    header  = *(uint*)current;

            switch( GetTokenType(header)){
            case TERMINATE_SEQUENCE_NV:
              {
                return indexType;
              }
              break;
            case NOP_COMMAND_NV:
            
              break;
            case DRAW_ELEMENTS_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(mode, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
            case DRAW_ARRAYS_COMMAND_NV:
              {
                DrawArraysCommandNV* cmd = (DrawArraysCommandNV*)current;
                DrawArrays(mode, cmd->first, cmd->count);
              }
              break;
            case DRAW_ELEMENTS_STRIP_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(modeStrip, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
...

        enum DrawCommandSequenceNV(enum mode, enum indexType, void *address, sizei size)
        {
          enum modeStrip;
          if      (mode == TRIANGLES)            modeStrip = TRIANGLE_STRIP;
          else if (mode == LINES)                modeStrip = LINE_STRIP;
          else if (mode == LINES_ADJACENCY)      modeStrip = LINE_STRIP_ADJACENCY;
          else if (mode == TRIANGLES_ADJACENCY)  modeStrip = TRIANGLE_STRIP_ADJACENCY;
          else if (mode == QUADS)                modeStrip = QUAD_STRIP;
          else    modeStrip = mode;

          enum modeSpecial;
          if      (mode == LINES)      modeSpecial = LINE_LOOP;
          else if (mode == TRIANGLES)  modeSpecial = TRIANGLE_FAN;
          else    modeSpecial = mode;

          void *current = address;
          
          while (current != (ubyte *)address + size) {
            uint    header  = *(uint*)current;

            switch( GetTokenType(header)){
            case TERMINATE_SEQUENCE_NV:
              {
                return indexType;
              }
              break;
            case NOP_COMMAND_NV:
            
              break;
            case DRAW_ELEMENTS_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(mode, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
            case DRAW_ARRAYS_COMMAND_NV:
              {
                DrawArraysCommandNV* cmd = (DrawArraysCommandNV*)current;
                DrawArrays(mode, cmd->first, cmd->count);
              }
              break;
            case DRAW_ELEMENTS_STRIP_COMMAND_NV:
              {
                DrawElementsCommandNV* cmd = (DrawElementsCommandNV*)current;
                DrawElementsBaseVertex(modeStrip, cmd->count, indexType, (void*)(cmd->firstIndex * sizeofindextype), cmd->baseVertex);
              }
              break;
...

etc

T

TechPizzaOP•4/8/23, 9:18 PM

oh no, i realized i can do software conditional rendering in veldrid, how cursed

L

Lyris the Kitori•4/8/23, 9:19 PM

display lists in FFP hint towards it being internally "compiled" to a faster internal sequence of commands, that you cant achieve with normal calls

L

Lyris the Kitori•4/8/23, 9:19 PM

does it actually do that? idk

L

Lyris the Kitori•4/8/23, 9:19 PM

maybe?

T

TechPizzaOP•4/8/23, 9:19 PM

yeah so we put your verts in a buffer, no need to thank us

P

Perksey•4/8/23, 9:19 PM

just think of what you can do with all of those nanoseconds

T

TechPizzaOP•4/8/23, 9:20 PM

doing millions of glVertex calls per frame in java unironically counted up REAL fast

P

Perksey•4/8/23, 9:20 PM

i'd imagine it'd be the same with C#

L

Lyris the Kitori•4/8/23, 9:20 PM

im wondering if it was intended to be put in GPU memory and GPUs were intended to be built to execute commands from some internal buffer

P

Perksey•4/8/23, 9:20 PM

there's no way to say "ok GC i'm going to need you to get ALL the way off my back please"

LLyris the Kitori im wondering if it was intended to be put in GPU memory and GPUs were intended t...

L

Lyris the Kitori•4/8/23, 9:20 PM

so the CPU just puts your recorded commands and tells the GPU to read all those

PPerksey i'd imagine it'd be the same with C#

T

TechPizzaOP•4/8/23, 9:21 PM

the only problem is that java jni is somehow like 10x worse than c# pinvokes

L

Lyris the Kitori•4/8/23, 9:21 PM

thats because its using java

i actually ported msvc std source to c# with a `Ref<T>` helper lol

Similar Threads