MSAA and Scene anti aliasing

[Chien Yang]

Hi Richard,

     Yes, I agree an enum is probably better than a boolean for 
controlling the visual quality of a rendered scene. As a matter of fact 
we did explore using enum is earlier 3d discussions but decided to go 
with boolean due to concerns of complexity we aren't ready to handle for 
JavaFX 8.0. There is quite a few anti-aliasing techniques and MSAA is 
just one that is easy to implement at the moment. The number of samples 
can range from 0 to 16 (or more in the future) and max samples is device 
dependence. If we were to put this detail information/control into an 
enum, it can turn ugly pretty fast. Also what if the selected technique 
or number of samples is not support on the device? We will probably have 
to provide some query mechanisms too.

The other approach, that may be doable for this release, is to let user 
tell us what is preferred, and we will pick the level the device is 
capable of supporting:

public enum SceneAntiAliasing {
     DISABLED,  // prefer performance over quality
     DEFAULT,   // Help me to decide
     NICE,      // good mix of performance and quality
     NICEST     // prefer quality over performance
}

What do you think?

- Chien



On 7/12/13 10:55 AM, Richard Bair wrote:
> Thor recently pushed an implementation for MSAA for those cases when the feature is supported by the card and where a Scene (or SubScene) is created with the antiAliasing flag set to true. MSAA is "Multi-sampled Anti Aliasing", which means that the graphics card, when configured in this mode, will sample each fragment multiple times. The upshot is that 3D doesn't look as jaggy.
>
> However this has an impact on performance (usually an extra buffer copy or at the very least you will be sampling each pixel multiple times so if you are doing something graphically intense then that might push you over the edge where you start to see performance degradation). Now multi-sampling can be 2x, 4x, etc. The higher the multi-sampling value, the better the quality, and the lower the performance.
>
> I'm also bothered but the name "antiAliasing" because there are many forms of anti-aliasing in the world and it isn't clear which this is. I think perhaps we should instead have an enum. The idea is that we can add to the enum over time with greater options for how to perform the scene antialiasing.
>
> public enum SceneAntiAliasing {
>      DISABLED,
>      DEFAULT,
>      MSAA_2X,
>      MSAA_4X
> }
>
> And then grow it over time to include potentially other techniques. My thought here is that the implementation is going to matter to folks. They're going to want to be able to make the performance / quality tradeoff, and perhaps even the implementation tradeoff (since different implementations may provide somewhat different results). DISABLED turns it off, obviously. DEFAULT allows us to pick what we think is the best (might be different on different platforms. Desktop might go with MSAA_16x or equivalent while iOS might be MSAA_2X). Then some standard options.
>
> Thoughts?
> Richard