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

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

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

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

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

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

P

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

engines can just do this

T

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

veldrid moment

P

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

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

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

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

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

T

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

pfft so true angryturtle

K

khitiara•4/8/23, 9:55 PM

yall talking about fixed function stuff and im getting flashbacks to minecraft modding back in like 2014 when i last did it

K

khitiara•4/8/23, 9:55 PM

fixed function all the way all in java jni and it all was awful

H

Howie•4/8/23, 11:49 PM

Anyone do any Entity Component System stuff with all the data stored in GPU buffers? I'm trying to figure out the best balance between ease of use and compactness. I've got something working, but it doesn't feel quite right.

M

MasterMan•4/9/23, 11:48 AM

Has anyone got this exception when calling D3D12 CreateDevice?

The GPU will not respond to more commands, most likely because some other application submitted invalid commands. The calling application should re-create the device and continue. (0x887A0007)

I googled around, but didn't find any proper solution

M

MasterMan•4/9/23, 11:49 AM

Some say that OS needs graphics tools for debugging installed, official MS page lists this code as this:

M

MasterMan•4/9/23, 11:50 AM

To clarify, my laptop has 2 GPUs, might there be a problem if the application is launched on default GPU (Intel), but NVIDIA is used to create the D3D device?
upd: seems not related, just tested

P

PerkseyOP•4/9/23, 11:56 AM

I recommend activating the info queue to see if any debug messages pop through

Similar Threads