Open GL should support konkave polygons directly

And the calculations will be wrong.

Therefore the stencil-buffer is existing

And what if the programmer is already using the stencil buffer for something else? Besides which, do you even know where stencil test runs in the pipeline relative to clipping and polygon division? Or that stencil test is dependent on clipping and polygon division? You really haven’t thought this through at all, have you?

You’re now moving well away from “direct support” and towards “crutched up by a load of fragile hacks that are going to break if you even look funny at them”.

As promised:

WHY SHOULD IHVs IMPLEMENT THIS?!

[QUOTE=Alfonse Reinheart;1254311]As promised:
WHY SHOULD IHVs IMPLEMENT THIS?![/QUOTE]
cause it´s cool :biggrin-new:

GL_LINE_LOOP can be rendered very fast:
http://wiki.delphigl.com/index.php/glBegin
[ATTACH=CONFIG]499[/ATTACH]
Where should be the problem, to fill the inner side of these areas with pixels also
verry fast ?
Rediculous, that it´s not able !

I move that a mod or admin close this thread. To me, the already next-to-zero value of this thread went straight to zero with “cause it´s cool”.

Buffers in OpenGL:

  • Color buffers: front-left, front-right, back-left, back-right (und evtl. weitere)
  • Depth buffer (z-buffer)
  • Stencil buffer
  • Accumulation buffer

I suggest a new one:

  • Polygon rendering buffer

That would be cool.

I hereby announce, that a next cosmic speed of idiocy has been just achieved in this thread.

No, it’s actually a great idea. You see, there’s little magic elves that live inside your graphics card, and sometimes they can be a bit stubborn, but if you tell them “because it’s cool” they can get motivated and do some work for you. So, with a polygon rendering buffer they can take concave polygons and sprinkle magic elf dust all over them and thereby make those concave polygons be natively supported.

Or something.

And here you can see, how it works:
left side: polygon Buffer ( help for construction to mark cross points, endpoints and the single lines ),
right side: frame buffer/color buffer with the rendered polygon
[ATTACH=CONFIG]500[/ATTACH]
The polygon buffer is cleared in the same loop as the frame buffer will be filled,
so the next polygon can be rendered
cool :cool:

here, I found an interesting discussion from Thursday, July 27, 2006
a guy suggested to use the stencil buffer for
Hardware accelerated polygon rendering

“… So in the spirit of writing down about the things I’m working on on a daily basis today comes hardware accelerated rendering of complex polygons. Ignacio Castaño finally convinced me to this ingenious method so all credit for it should go to him. I’ve spent last few moments at the office today looking into this method and it’s just gorgeous so I’ll give a brief overview of it…”


here a comment from the linked page:
“The method is awesome, as it (in theory) doesn’t involve any kind of client side computations (besides a trivial min/max test) and (again in theory) operates in whole on the hardware. A wonderful sideeffect of all of this is that we avoid robustness issues that tessellation introduces.”

Who is Ignacio Castaño ? :
https://twitter.com/castano/status/258414324949868545

http://www.linkedin.com/in/castano
http://www.ludicon.com/castano/blog/about/resume/
actual: Senior Programmer at Thekla
former: Developer Technology Engineer at NVIDIA
3D Tools and Technology Engineer at NVIDIA
Game Programmer at Oddworld Inhabitants
Graphics Programmer at Relic Entertainment, Inc
Graphics Programmer at Nebula Technologies, SA
Lead Programmer at Crytek GmbH


its said “the method is awsome” - as I say it´s cool
----------------------------------------------------------------------------------------------------------------------

If there would be an new polygonbuffer, it could be combined with the stencil buffer, which could do it´s native job.
That would be great.

This “polygon buffer” method works great when you draw polygons sequentially, anything deserving the attribute “fast” on a GPU has to work parallelized.

It could be parallelized like existing tasks which belong to other buffers within a GPU.

this example here shows, that a polygon buffer could also support an optimal font supply directly within the GPU:

and here it´s missed also:

let´s do it