we have used a fair bit of cpu to avoid gpu overhead and this tunes
the balance back a bit to throwing more at the gpu and less at the cpu
by reducing the number of pipes and max vertex counts per pipe by
default and only resetting pipe state vars if adding the first pipe
member.
@opt
Summary: This is the first version of inverse color filter both GL and SW.
Test Plan:
1. Create filter_example with following .
efl_gfx_filter_program_set(image, "inverse_color ()", "inverse color");
2. Run.
./filter_example (Use ELM_ACCEL=gl for GL engine)
Reviewers: Hermet, jsuya
Reviewed By: Hermet
Subscribers: cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10335
Summary:
Initial version implementing grayscale filter in pure GL.
This patch needs a logt of love as 5bce712 did.
Grasyscale formula:
https://www.tutorialspoint.com/dip/grayscale_to_rgb_conversion.htm
Test Plan:
1. Create filter_example with following .
efl_gfx_filter_program_set(image, "grayscale ()", "grayscale");
2. Run.
ELM_ACCEL=gl ./filter_example
Reviewers: Hermet, jsuya
Subscribers: ali.alzyod, cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D9858
If we check reference validation, the rest of other usage
should keep the reference check as well.
Remove it since gl prorgram must be valid always here
to shutdown the static analyzer reporting this suspicous logic.
Summary:
GL engine has used integer coordinates system since it's born though
OpenGL basically uses floating point vertex coordinates system.
There were many dissatisfaction, complaints about this
since object's transition is jiggled, not perfectly smooth.
It's obvious because Positioning must be stepping with integer units
without any subpixel rendering.
Our gl engine currently supports msaa options and evas map allows to
have double precivion coordinates system, our engine must do handle this over as well,
to work together.
If you don't like change,
We could switch behaviors optionally (turn on, only when msaa is enabled)
But I think it's pointless using integer coordinates system in GL thesedays.
It just make code complex to maintain.
There will be an additional patch coming for SW backend map behavior soon.
Left: before patch
Right: after patch
{F3694624}
Reviewers: #committers, raster
Reviewed By: #committers, raster
Subscribers: raster, cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D8552
Summary:
GLPIPES is proved to use since it's been used for many years as the default.
On the other hand, single-line routine hans't, acutally it's not maintained properly.
Even this single-line routine doesn't compileable right moment.
This patch is one refactoring to clean up code that's not valuable to maintain.
Reviewers: #committers, raster, cedric, ManMower
Reviewed By: #committers, ManMower
Subscribers: ManMower, cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D7328
Summary:
Map context missed setting texture target.
I guess this is one of regression bugs in gl backend.
When shader is flushed, it sets invalid texture target with map texture.
That caused blank map rendering, this could be observed temporary
because gl pipe contexts are reusable and missing texture target means,
it could use previous texture target values that mostly have GL_TEXTURE_2D.
@fix
Reviewers: #committers, ManMower
Reviewed By: #committers, ManMower
Subscribers: ManMower, cedric, #reviewers, #committers, zmike
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D6818
strstr() can give false positives if the extension name is a subset of
a string in the extension list, for example EGL_EXT_image_dma_buf_import
would match EGL_EXT_image_dma_buf_import_modifiers.
I've opted for a mildly badgered copy of epoxy's test, which should be
robust in the face of subsets.
This is very useful to specify precisely which kind of RGBA -> Alpha
conversion you want. If all you wanted was the alpha layer to use as a
mask, set this flag to true.
@feature
A recent commit broke texture_from_pixmap for NVIDIA EGL
(again), because eglCreateImage is a symbol in libEGL.so
but isn't in fact implemented by the driver.
That's because eglCreateImage() is exposed by libglvnd but
the underlying EGL implementation is NVIDIA and its version
is only 1.4, not 1.5 (where the API was introduced as core).
Instead of reverting the patch, it's better to cover our
bases properly and use dlsym() only if the version is right.
Note that GetProcAddress() may return garbage function
pointers for ALL functions as dynamic virtual functions may
be created on the fly by libglvnd. So it is absolutely
necessary to check the extension string as well.
See 0255f14dc2
eglCreateImage is objectively better than eglCreateImageKHR - it allows
attributes large enough to hold pointer values. We should use it when
available and only use the older extension version as fallback.
Also, eglCreateImage is core EGL functionality so don't depend on extensions
to be present to use it. Theoretically we should be testing for
EGL version >= 1.5 but it's probably safe not to.
This was only necessary due to bugs in the wayland_egl and gl_drm engine
that have been corrected.
Wayland has no bizarre requirements making this necessary.
These aren't a thing. the GL_OES_EGL_image_base extension doesn't exist
and the GL_OES_EGL_image extension doesn't extend egl, because it's a gl
extension.
So let's stop being the only google match for these nonsense strings.
this fixes an issue that has cropped up in the past few months - only
nvidia drivers with egl/gles in x11... and compositing won't work
(native surface) and the introduction of libglvnd
it's a combination of libglvnd lying that it has symbols it can't
later find, new features to get core functions via procaddress that we
hadn't migrated to use AND use preferring core functions that libglvnd
will expose, so switching to KHR extensions by preference. we also
need to symmetrically use destroy image khr too...
oddly enough using procaddress purely for create/destroy image makes
wayland fail ... sofor now i'm taking advantage of the fact that
wayland has no extensions string passed in at the moment and still
doing dlsym... this is odd though.
@fix
This can help with performance when a large region of the
filtered image (eg. snapshot) is fully hidden by an opaque
object. For instance the window border is hidden by the
opaque window content.
This was a poor attempt at improving the performance but
obviously the root cause isn't fixed (too many texel fetches).
Uniform should (theoretically) work better than an attribute
the for loop. Just a guess here.
This also makes GL blur use a float value as radius, allowing
future extension to non-integer blur radii, as well as using
linear scaling as a fast blur approximation.
This optimizes the GL blur algorithm by reducing the number of
texel fetches (roughly half the number of before this patch). This
works by exploiting GL's interpolation capabilities.
By simply splitting X and Y blurs in two passes we can improve
the performance of the blur filter a lot.
There is still much to be done to make it really fast and nice
looking:
- implement true gaussian blur (not sine-based approximation,
right now the actual blurs look different in SW and GL)
- exploit linear interpolation for R tap instead of R*2+1 taps
(a tap being a texel fetch)
- downscale & upscale large images with large blur radii
Wait a second though, this implementation is not only incomplete
(no support for box vs. gaussian blur), it's also insanely bad in
terms of performance. Small radii may work fine, but at least blurs
render properly in GL with this patch (no more glReadPixels!).
The shader needs a lot of love, including in particular:
- support for 1D box blur single pass
- support for 1D gaussian (or sine) blur
- use linear interpolation and N-tap filters
- separation of 2D blur in two passes (high-level logic)
- potentially separation of large 1D blurs in 2 or more passes
knowing that 2sigma == sigma + sigma when it comes to the gaussian
bell curve.
This one was a bit more... "fun". I had to add a new vertex
attribute and obviously using a VertexAttribPointer led to
incomprehensible crashes. But a simple glVertexAttrib2fv makes
it work like a charm!
A rare option is not handled yet.
This reuses the existing mask infrastructure, but adds a color
flag to use the whole RGBA range, rather than just the Alpha
channel.
Filters are still very slow (glReadPixels and non-optimized use of
GL buffers...), but this is progress :)
The things you learn to love...
The situation was:
- An object is mapped (naviframe in an animation)
- One of its children has a mask
- The window is rotated by 90 or 270 degrees (landscape)
The mask glsl code to invert the x,y coordinate depends on the
screen rotation and this somehow was wrong.
Tested on Tizen and in elm_test "Masking", made with @jiin.moon.
@fix
If GL context is free'd before processing font shutdown,
textures for emoji glyph's GL images will be free'd without clean
up its GL images. It causes eina mempool infinite loop issue when
emoji's GL images are free'd in shutdown process.
So, the patch will make a list for emoji's GL images in context and
clean up them when the context is free'd. Just like font textures in
context.
@fix
Differential Revision: https://phab.enlightenment.org/D4695
Signed-off-by: Jean-Philippe Andre <jp.andre@samsung.com>
It was assumed that GLES 3 would only work with EGL but in fact
OpenGL 4.3 & 4.5 are supersets of GLES 3.0 & 3.1 respectively. So
GLX should also support GLES 3.0 or GLES 3.1 for evas gl, if the
driver supports it, of course.
Of course while doing this patch things didn't go like they were
supposed to go. I'm currently using NVIDIA's proprietary driver,
that conveniently provides EGL with GLES 3.2. But wait, there's
a catch: GL_VERSION is "OpenGL ES 3.2 NVIDIA" except that none
of the functions of GLES 3.1 or GLES 3.2 are actually supported.
Those functions are only present in the GLX/OpenGL variant of the
driver. Thanks so much for making my life easier...
So yeah, this patch contains a hack for those invalid versions
of GLES 3.x. What was supposed to be a small fix became a huge
mess.
Also add a comment about the possibly invalid auto-upgrade from
GLES 2 to GLES 3.
This adds a test case in elm_test, but only to verify that
elm_glview_version_add(3) actually works. We need a proper GLES 3
test case, eventually (and 3.1, 3.2 of course).
This should fix an ERR message under gl_drm and probably an
actual bug.
This reverts 8f2cfdf490.
I don't think the texture target should be part of the context
information. It should instead be a property of the texture.
Fixes T5171
MSAA (multisampled_render_to_texture) support was implemented with
GLES 2 in mind, but for GLES 3 it comes as a core feature, not as
an extension. Also it relies on renderbuffers, not textures. GL
is awesome.
Note: MSAA still doesn't work!
newframe() resets some of the gl context properties, so match them
to our shadow copy in the gc state.
target_surface_set() also resets some of those properties but only
in our shadow copy, not in the actual GL context. As a consequence
we can't rely on setting a bool to 0 or 1 unless we also call the
equivalent GL function. Expand bitfields to 2 bits allows us to
set a bool to the invalid value of -1 (yes, that's not a real bool).
Also there is no need to reset the target surface to NULL during
newframe. It will be reset during target_surface_set.
This fixes some issues I encounter while working on GL filters.
this improves performance a bit by avoding libc's malloc and the heap
by using a custom buffer pool thathas basically immediate O(1) lookup
time (in real life) that baloons out and contracts back as time goes on.
@optimize
The first patch did not work for maps. This explains why the
original code was so weird. But it actually made sense.
After struggling a bit I realized that we really just need
to shuffle around the pixel position on the window to map that
of the position in the canvas (unrotate it).
Note that compatibility with GLSL-ES (for OpenGL ES) implies
we can not use an array initializer like:
vec2 pos[4] = vec2[4](a,b,c,d);
So the code could probably be optimized. But at least this works.
This patch also avoids calling glGetUniformLocation again and
again.
Carsten Haitzler
Elyes HAOUAS
Hermet Park
Mike Blumenkrantz
Ali Alzyod
Hermet Park
Shinwoo Kim
Derek Foreman
Jean-Philippe Andre
Youngbok Shin
Subhransu Mohanty