Would it be possible to have frames with zero draw calls?

Modern API's like Vulkan and DirectX 12 aim to massively reduce the bandwidth between CPU and GPU.

So could you have a scene where nothing moves and therefore no additional draw calls are needed?

Or the whole of a scene in GPU memory and only move the camera so no additional draw calls are needed?

 

No?

 

For something like that you'd need a very advanced software that lets you choose when to call the render function such as Blitz3D :B

But that's too leet

 

Wouldn't a frame with zero draw calls simply be a blank frame?

 

Yes. "Clear backbuffer" is not technically a draw call. So you can have a blank frame.

 

Whats the point? Draw calls are not inherently evil. To many of them can overload your CPU, yes.

Why not go with "low amount of drawcalls" and call it a day instead of striving for the impossible?

 

Make an audio-only game and your entire project can have zero draw calls!

 

A "draw call" is a set of api instructions typically to setup what material will be used... where a material really is a set of instructions relating to rendering like loading a shader, setting up a texture, enabling multitexturing, setting up lighting, etc. So usually when a texture or shader changes or is modified it invokes the need for a new draw call. So even if you had a totally stationary scene, if it were not able to use a single material shared by every single model, it will still require multiple draw calls. The API and the hardware would both have to support multiple simultaneous draw-calls, ie storage of many more instances of settings, in order for you to in any way overcome this.

 

Ha... the witty would respond to that that you could draw the screen once and then never refresh it, while the game engine idles away in the background (thus technically, there still is a "frame" every 1/60 second). No idea if Unity supports that kind of lazy screen refresh though.

Also, I have no idea what the point of that should be... but hey, its an Arowx thread, so I would not even date to ask that question.

 

You'll still need to draw UI.

 

No, audio only! It's just a blank screen with audio prompts to do things, and audio-only feedback! Like a game for 100% blind people.

 

The real challenge is making a game without visuals nor audio! :B

 

I think something like that was released on steam actually. It still had an ui. Audio only game. I forgot what it was called, though.

 

I think I'm up to that challenge...

Sounds like they halfassed the "audio only" portion to me, then.

 

It might be possible to write a shader that does caching. That might work. Or it might not.

 

Not.

 

Zero draw calls on the GPU:

 

I would think you can probably get close to 1 draw call for a scene, even if its animated or the camera is moving or whatever.

Or if you want zero, render your scene into a render texture in one frame, then in the next frames, just render the rendertexture to the backbuffer... but oh... wait, texture mapping requires a draw call. Darn it.

 

Sure, you can get one, as an experiment when the Sprite system was introduced a few years back, I made a solitaire game with that goal in mind. I was able to do it in a single draw call, jamming everything onto a single texture. Not particularly practical or performant, but doable.

For zero, you can just remove all cameras and canvases.

 

Fair enough. I've written exactly one shader so far, so I defer to your experience.

Is shader caching actually a thing at all? Or am I making stuff up.

Its actually possible to get far better graphics performance on that platform, however it often comes at the cost of player processing time.

 

Well, yes, but not in the way you suggested. As in caching results. Think of a shader as a static method, like Vector3.Distance or Mathf.Abs. You pass it a bunch of data, it returns a color. (for a frag, for example). It really isn't aware of much. But even if hypothetically it was aware of what it did last time, running it to return that stored result would still be a draw call, though you would be trading calculatation speed for memory storage/retrieval.

 

Makes sense. I like the static analogy.

My mind is currently running away with possibilities faster then my skill with writing shaders. It will calm down again soon.

 

Actually, I think it is theoretically possible to have exactly one drawcall.

You'll need a scene drawn by raycasting shader. Then you'll need to plug in the whole world as data into that shader. It won't be terribly fast or terribly efficient but it can be done.

I think it can actually be done. Not 100% sure of it and haven't explored it.
Basically, compute shaders can write to data, and both OpenGL/Directx should have writeable storage objects accessible from shaders.
https://www.opengl.org/wiki/Shader_Storage_Buffer_Object
http://stackoverflow.com/questions/32094598/opengl-compute-shader-ssbo

 

Well... Yes it 'could' be done, but that is typically for more complex processes. Using buffers for caching results from an optimized shader pass(s), wouldn't necessarily result in a time reduction, and wouldn't reduce draw calls as the shader (material) is still performing the action. Though as mentioned before, draw calls by themselves aren't a strong performance metric. Caching type functionality can be handled more optimally in other parts of the rendering pipeline.

 

Like this? https://www.shadertoy.com/view/MddGzf

 

Pretty sweet!

 

It's probably really super inefficient to be running in a GPU, but it works

 

Sure it is very inefficient, but so is playing Tetris on building with christmas lights:

Or playing Doom on a printer:

Or Defender in a favicon:
http://www.p01.org/defender_of_the_favicon/

Or building a low resolution aerial display using 100 synced drones:

Efficiency be damned! Cool is just cool!