Am I correct in assuming that OpenGL will treat raw vertexes without model or projection matrices as

MMachinarius Am I correct in assuming that OpenGL will treat raw vertexes without model or pr...

P

Perksey•4/8/23, 6:49 PM

yup

PPerksey here's a cursed prototype i came up with just now <https://sharplab.io/#v2:CYLg1...

T

TechPizza•4/8/23, 7:01 PM

oh no, a static readonly instead of a static property when

T

TechPizza•4/8/23, 7:01 PM

i actually ported msvc std source to c# with a

Ref<T>

Ref<T>

Ref<T>

Ref<T> helper lol

T

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

it was basically a

ref

ref

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

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

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

T

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

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

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

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

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

TechPizza•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"

Am I correct in assuming that OpenGL will treat raw vertexes without model or projection matrices as

Similar Threads