Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Topics - JeGX

Pages: 1 ... 14 15 [16] 17 18 ... 35
Announced earlier this week, the next-gen version of OpenGL is a complete, from-the-ground-up rewrite aimed at slashing overhead and giving developers more control over the hardware. In that sense, the upcoming API, which Huddy calls "OpenGL Next," will follow in the footsteps of Mantle and DirectX 12.

Huddy told us AMD has done a "great deal of work" with the Khronos Group, the stewards of the OpenGL spec, on OpenGL Next. AMD has given the organization unfettered access to Mantle and told them, in so many words, "This is how we do it. If you want to take the same approach, go ahead." Khronos is free to take as many pages as it wants out of the Mantle playbook, and AMD will impose no restrictions, nor will it charge any licensing fees.


3D-Tech News Around The Web / SIGGRAPH 2014: DirectX 12 on Intel
« on: August 15, 2014, 04:27:12 PM »
This week at SIGGRAPH 2014 Intel is showing a technology demo using Microsoft's upcoming DirectX 12 API that highlights the strong relationship between performance and power.

In the demo we render a scene of 50,000 fully dynamic and unique asteroids in one of two modes: maximum performance and maximum power saving. The application can switch between using the DirectX 11 and DirectX 12 APIs at the tap of a button. We are showing the demo in our SIGGRAPH booth running live on a Microsoft Surface Pro 3 tablet with an Intel® 4th Generation Core™ processor.

All of the results here were captured when the tablet was running in a steady, thermally-constrained state. This represents the experience of playing a demanding game for more than 10-15 minutes.



Image blur filters are commonly used in computer graphics – whether it is an integral part of a Depth of Field or HDR Bloom, or another post process effect, blur filters are present in most 3D game engines and often in multiple places. Blurring an image is a fairly trivial thing to do: just collect neighboring pixels, average them and you get your new value, right?

Well, yes, but there are different ways of doing it with different visual results, quality and performance.

In this article I’ll focus primarily on performance (and quality trade-offs), as the difference in cost between a naïve and a more optimal solution can sometimes be an order of magnitude, but also different algorithms can be more optimal on different hardware.


OpenGL 4.5 Specification Released

Khronos publicly released the OpenGL 4.5 specification today, bringing the very latest functionality to the industry’s most advanced 3D graphics API while maintaining full backwards compatibility, enabling applications to incrementally use new features. The full specification and reference materials are available for immediate download from the OpenGL Registry. New functionality in the core OpenGL 4.5 specification includes:

  • Direct State Access (DSA) – object accessors enable state to be queried and modified without binding objects to contexts, for increased application and middleware efficiency and flexibility;
  • Flush Control - applications can control flushing of pending commands before context switching – enabling high-performance multithreaded applications;
  • Robustness - providing a secure platform for applications such as WebGL browsers, including preventing a GPU reset affecting any other running applications;
  • OpenGL ES 3.1 API and shader compatibility – to enable the easy development and execution of the latest OpenGL ES applications on desktop systems;
  • DX11 emulation features – for easier porting of applications between OpenGL and Direct3D.

Complete press release:

Forum en français / Leap Motion (GLSL Hacker v0.7.0.2+)
« on: August 05, 2014, 05:19:08 PM »
Un article sur le controlleur Leap Motion est disponible ici:

Le support du Leap Motion a été ajouté dans GLSL Hacker (plugin dispo pour Windows et OS X). Pour le moment le support du Leap Motion est limité à la position et orientation des os des doigts ainsi que la position et orientation de la paume de la main.

La demo est dispo dans le répertoire host_api/LeapMotion/ du demopack de GLSL Hacker:

English forum / Leap Motion (GLSL Hacker v0.7.0.2+)
« on: August 05, 2014, 05:15:22 PM »
An article about the Leap Motion device is available here:

GLSL Hacker comes with the support of the Leap Motion controller. This support is currently limited to the position and orientation of the bones of the fingers and  the position and orientation of the palm of the hand.

The demo is available in the host_api/LeapMotion/ folder of the code sample pack:

3D-Tech News Around The Web / Metal, a new graphics API for iOS 8
« on: July 03, 2014, 04:32:38 PM »
At its recent World Wide Developers Conference, Apple introduced Metal, a new graphics API that’s low-overhead, high efficient, and designed specifically for the A7 chip. It provides a way for game makers to take full advantage of iOS hardware and achieve far greater realism, detail, and interactivity in their games than ever before.

We’ll be adding support for Metal soon, but in advance, wanted to take you through the new technology and explain why it is such a big deal.


3D-Tech News Around The Web / DirectXMesh geometry processing library
« on: July 02, 2014, 06:47:30 PM »
DirectXMesh, a shared source library for performing various geometry content processing operations including generating normals and tangent frames, triangle adjacency computations, and vertex cache optimization.


Voila un petit tuto d'introduction aux shader subroutines d'OpenGL 4.0 (en français):

Forum en français / Rendu de l’Attracteur de Lorenz
« on: June 30, 2014, 09:36:29 AM »
Le rendu de l'attracteur de Lorenz ça vous dit? Alors allez visiter cette page:

Forum en français / Effet 2D: le Twirl (ou Swirl) en GLSL
« on: June 30, 2014, 09:32:31 AM »
Voilà un petit article sur un effet de déformation 2d bien connu: le twrirling ou swirling:

Cet article est dispo sur un nouveau blog en français que je vais essayer de mettre à jour aussi souveant que possible.

English forum / Twirl Effect
« on: June 25, 2014, 02:26:45 PM »
- What: twirl effect shader

- Where: in the host_api/PostFX/Twirl/ folder of the code sample pack

- When: in few hours, during the next update/upload of the code sample pack.

English forum / GLSL Hacker released
« on: June 23, 2014, 09:35:30 PM »
A new dev version of GLSL Hacker is ready for Windows 64-bit, Linux 64-bit and OS X.

You can download it from this page:

Version - 2014.06.21
* fixed a bug with AntTweakBar plugin under Windows with AMD Radeon cards
  that made the application to crash time to time at the end of a scene.
- removed all atomic_counter_xxxx() functions from gh_renderer.   They are
  replaced by the low level functions of the gh_gpu_buffer lib.
* bugfix: the gh_camera.bind() function no longer update the fixed pipeline
  if OpenGL core profile is used.
+ added OpenGL debug GL_ARB_debug_output support via the gl_debug_profile="1"
  in the XML window node.
+ added memory_barrier() to gh_renderer lib.
+ added vertices_to_gpu_buffer(), vertices_from_gpu_buffer()
  and set_vertex_source() to vertex_pool lib.
- removed all shader_storage_buffer_xxxxx() functions from vertex_pool lib.
+ added set_shader_storage_block_binding() to gh_gpu_program lib.
+ added set_automatic_uniform_state() to gh_object lib.
* fixed a threading bug in the waitscreen + progress bar when scene contains errors.
+ added gh_gpu_buffer, a new lib for managing GPU buffers in an unified way.
+ added get_uniform_block_size(), get_uniform_block_index()
  and set_uniform_block_binding() to gh_gpu_program lib.
- removed all ub_xxx() functions from gh_gpu_program lib.

Version - 2014.06.08
+ added support of transparent windows (alpha value) in OS X version.
+ added drag and drop support in the OS X version.
! OSX version: now GLSL Hacker stores the last position of the window
  and uses it for the next launch (useful with the drag and drop).
+ added FreeImage plugin support in the OS X version.
+ added a set of functions to manage custom dynamic libraries: gh_utils.dylib_xxx().
  Thanks to these functions, you can use GLSL Hacker as a super window manager and code
  your own 3D routines in the dynamic lib in C/C++.   

English forum / GPU buffers
« on: June 23, 2014, 03:31:33 PM »
GPU buffers are a powerful new feature of GLSL Hacker 0.7.0+. A GPU buffer is a wrapper around OpenGL hardware buffer objects. You can easily create an uniform or shader storage buffer, set values and use the buffer in a GLSL shader.

Here is a code snippet (in Lua) that illustrates how to use GPU buffers functions of the new gh_gpu_buffer lib:

Code: [Select]
storage_size = 32 -- memory size in bytes for two vec4
flags = ""
ssbo = gh_gpu_buffer.create("SHADER_STORAGE", "GL_DYNAMIC_READ", storage_size, flags)

buffer_offset_bytes = 0
gh_gpu_buffer.set_value_4f(ssbo, buffer_offset_bytes, x0, y0, z0, w0)

buffer_offset_bytes = buffer_offset_bytes + 16
gh_gpu_buffer.set_value_4f(ssbo, buffer_offset_bytes, x1, y1, z1, w1)



binding_point_index = 3
gh_gpu_buffer.bind_base(ssbo, binding_point_index)

More complete examples are available in the code sample pack:

- host_api/gl-310-arb-uniform-buffer/
- host_api/gl-420-arb-atomic_counters/
- host_api/gl-430-arb-shader-storage-buffer-object/
- host_api/gl-440-arb-bindless-texture/

All these code samples use GPU buffers to share data with GLSL programs.

English forum / User plugins in C/C++
« on: June 23, 2014, 03:04:35 PM »
GLSL Hacker 0.7.0+ brings the support of user plugins (or dynamic/shared libs: *.dll under Windows, *.so under Linux and *.dylib under OS X). These dynamic libraries must implement the following functions:

Code: [Select]
int gxl_dylib_start(void* render_window, int width, int height, const char* data, void* user_data);
int gxl_dylib_stop(const char* data, void* user_data);
int gxl_dylib_frame(float elapsed_time, const char* data, void* user_data);
int gxl_dylib_resize(int width, int height, const char* data, void* user_data);
int gxl_dylib_set_message(const char* message);
char* gxl_dylib_get_message();

render_window is a pointer on the following data structure:
Code: [Select]
struct RenderWindowData_v1
  HDC _dc; // Device context.
  HWND _hwnd; // Handle on the 3D window.
  HGLRC _glrc; // OpenGL context.

#if _OSX
  void* _glrc; // OpenGL context.

#if _LINUX
  Display* _display; // not set, alwyas = 0
  Window _window; // not set, alwyas = 0
  void* _glrc; // OpenGL context.

Once your DLL is coded with these functions, you can load it and use it in GLSL Hacker:

INIT script:
Code: [Select]
dlib = gh_utils.dylib_load(dylib_filename)
plugin_data = ""
gh_utils.dylib_start(dlib, winW, winH, plugin_data)

FRAME script :
Code: [Select]
plugin_data = ""
gh_utils.dylib_frame(dlib, elapsed_time, plugin_data)

SIZE script :
Code: [Select]
winW, winH = gh_window.getsize(0)
plugin_data = ""
gh_utils.dylib_resize(dlib, winW, winH, plugin_data)

TERMINATE script :
Code: [Select]
plugin_data = ""
gh_utils.dylib_stop(dlib, plugin_data)

You can use the plugin_data variable to pass arbitrary string to the plugin.

A complete demo (including the DLL source code in C/C++ for Windows and OS X) is available in the host_api/User_Plugin/ folder of the code sample pack.

This demo initializes and draws a simple triangle:

Pages: 1 ... 14 15 [16] 17 18 ... 35