static void engine_bind_display_space_shader(RenderEngine *UNUSED(engine), Scene *scene)
{
IMB_colormanagement_setup_glsl_draw(&scene->view_settings,
&scene->display_settings,
scene->r.dither_intensity,
false);
}
void render_view3d_draw(RenderEngine *engine, const bContext *C)
{
Render *re = engine->re;
RenderResult rres;
int keep_data = render_view3d_changed(engine, C);
if (engine->flag & RE_ENGINE_DO_UPDATE)
render_view3d_do(engine, C, keep_data);
if (re == NULL) return;
RE_AcquireResultImage(re, &rres);
if (rres.rectf) {
Scene *scene = CTX_data_scene(C);
bool force_fallback = false;
bool need_fallback = true;
float dither = scene->r.dither_intensity;
/* Dithering is not supported on GLSL yet */
force_fallback |= dither != 0.0f;
/* If user decided not to use GLSL, fallback to glaDrawPixelsAuto */
force_fallback |= (U.image_draw_method != IMAGE_DRAW_METHOD_GLSL);
/* Try using GLSL display transform. */
if (force_fallback == false) {
if (IMB_colormanagement_setup_glsl_draw(NULL, &scene->display_settings, TRUE)) {
glEnable(GL_BLEND);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glaDrawPixelsTex(rres.xof, rres.yof, rres.rectx, rres.recty, GL_RGBA, GL_FLOAT,
GL_LINEAR, rres.rectf);
glDisable(GL_BLEND);
IMB_colormanagement_finish_glsl_draw();
need_fallback = false;
}
}
/* If GLSL failed, use old-school CPU-based transform. */
if (need_fallback) {
unsigned char *display_buffer = MEM_mallocN(4 * rres.rectx * rres.recty * sizeof(char),
"render_view3d_draw");
IMB_colormanagement_buffer_make_display_space(rres.rectf, display_buffer, rres.rectx, rres.recty,
4, dither, NULL, &scene->display_settings);
glEnable(GL_BLEND);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glaDrawPixelsAuto(rres.xof, rres.yof, rres.rectx, rres.recty, GL_RGBA, GL_UNSIGNED_BYTE,
GL_LINEAR, display_buffer);
glDisable(GL_BLEND);
MEM_freeN(display_buffer);
}
}
RE_ReleaseResultImage(re);
}
/* Draw given image buffer on a screen using GLSL for display transform */
void glaDrawImBuf_glsl(ImBuf *ibuf, float x, float y, int zoomfilter,
ColorManagedViewSettings *view_settings,
ColorManagedDisplaySettings *display_settings)
{
bool force_fallback = false;
bool need_fallback = true;
/* Early out */
if (ibuf->rect == NULL && ibuf->rect_float == NULL)
return;
/* Dithering is not supported on GLSL yet */
force_fallback |= ibuf->dither != 0.0f;
/* Single channel images could not be transformed using GLSL yet */
force_fallback |= ibuf->channels == 1;
/* If user decided not to use GLSL, fallback to glaDrawPixelsAuto */
force_fallback |= (U.image_draw_method != IMAGE_DRAW_METHOD_GLSL);
/* This is actually lots of crap, but currently not sure about
* more clear way to bypass partial buffer update crappyness
* while rendering.
*
* The thing is -- render engines are only updating byte and
* display buffers for active render result opened in image
* editor. This works fine to show render progress without
* switching render layers in image editor user, but this is
* completely useless for GLSL display, where we need to have
* original buffer which we could color manage.
*
* For the time of rendering, we'll stick back to slower CPU
* display buffer update. GLSL could be used as soon as some
* fixes (?) are done in render itself, so we'll always have
* image buffer with relevant float buffer opened while
* rendering.
*
* On the other hand, when using Cycles, stressing GPU with
* GLSL could backfire on a performance.
* - sergey -
*/
if (G.is_rendering) {
/* Try to detect whether we're drawing render result,
* other images could have both rect and rect_float
* but they'll be synchronized
*/
if (ibuf->rect_float && ibuf->rect &&
((ibuf->mall & IB_rectfloat) == 0))
{
force_fallback = true;
}
}
/* Try to draw buffer using GLSL display transform */
if (force_fallback == false) {
int ok;
if (ibuf->rect_float) {
if (ibuf->float_colorspace) {
ok = IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings,
ibuf->float_colorspace, TRUE);
}
else {
ok = IMB_colormanagement_setup_glsl_draw(view_settings, display_settings, TRUE);
}
}
else {
ok = IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings,
ibuf->rect_colorspace, FALSE);
}
if (ok) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(1.0, 1.0, 1.0, 1.0);
if (ibuf->rect_float) {
int format = 0;
if (ibuf->channels == 3)
format = GL_RGB;
else if (ibuf->channels == 4)
format = GL_RGBA;
else
BLI_assert(!"Incompatible number of channels for GLSL display");
if (format != 0) {
glaDrawPixelsTex(x, y, ibuf->x, ibuf->y, format, GL_FLOAT,
zoomfilter, ibuf->rect_float);
}
}
else if (ibuf->rect) {
/* ibuf->rect is always RGBA */
glaDrawPixelsTex(x, y, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE,
zoomfilter, ibuf->rect);
}
IMB_colormanagement_finish_glsl_draw();
need_fallback = false;
}
}
/* In case GLSL failed or not usable, fallback to glaDrawPixelsAuto */
if (need_fallback) {
unsigned char *display_buffer;
void *cache_handle;
display_buffer = IMB_display_buffer_acquire(ibuf, view_settings, display_settings, &cache_handle);
if (display_buffer)
glaDrawPixelsAuto(x, y, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE,
zoomfilter, display_buffer);
IMB_display_buffer_release(cache_handle);
}
}
void render_view3d_draw(RenderEngine *engine, const bContext *C)
{
Render *re = engine->re;
RenderResult rres;
char name[32];
render_view3d_do(engine, C);
if (re == NULL) {
sprintf(name, "View3dPreview %p", (void *)CTX_wm_region(C));
re = RE_GetRender(name);
if (re == NULL) return;
}
/* Viewport render preview doesn't support multiview, view hardcoded to 0 */
RE_AcquireResultImage(re, &rres, 0);
if (rres.rectf) {
RegionView3D *rv3d = CTX_wm_region_view3d(C);
View3D *v3d = CTX_wm_view3d(C);
Scene *scene = CTX_data_scene(C);
ARegion *ar = CTX_wm_region(C);
bool force_fallback = false;
bool need_fallback = true;
float dither = scene->r.dither_intensity;
float scale_x, scale_y;
rcti clip_rect;
int xof, yof;
if (render_view3d_disprect(scene, ar, v3d, rv3d, &clip_rect)) {
scale_x = (float) BLI_rcti_size_x(&clip_rect) / rres.rectx;
scale_y = (float) BLI_rcti_size_y(&clip_rect) / rres.recty;
xof = clip_rect.xmin;
yof = clip_rect.ymin;
}
else {
scale_x = (float) ar->winx / rres.rectx;
scale_y = (float) ar->winy / rres.recty;
xof = rres.xof;
yof = rres.yof;
}
/* If user decided not to use GLSL, fallback to glaDrawPixelsAuto */
force_fallback |= (U.image_draw_method != IMAGE_DRAW_METHOD_GLSL);
/* Try using GLSL display transform. */
if (force_fallback == false) {
if (IMB_colormanagement_setup_glsl_draw(&scene->view_settings, &scene->display_settings, dither, true)) {
glEnable(GL_BLEND);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glPixelZoom(scale_x, scale_y);
glaDrawPixelsTex(xof, yof, rres.rectx, rres.recty,
GL_RGBA, GL_FLOAT, GL_NEAREST, rres.rectf);
glPixelZoom(1.0f, 1.0f);
glDisable(GL_BLEND);
IMB_colormanagement_finish_glsl_draw();
need_fallback = false;
}
}
/* If GLSL failed, use old-school CPU-based transform. */
if (need_fallback) {
unsigned char *display_buffer = MEM_mallocN(4 * rres.rectx * rres.recty * sizeof(char),
"render_view3d_draw");
IMB_colormanagement_buffer_make_display_space(rres.rectf, display_buffer, rres.rectx, rres.recty,
4, dither, &scene->view_settings, &scene->display_settings);
glEnable(GL_BLEND);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glPixelZoom(scale_x, scale_y);
glaDrawPixelsAuto(xof, yof, rres.rectx, rres.recty,
GL_RGBA, GL_UNSIGNED_BYTE,
GL_NEAREST, display_buffer);
glPixelZoom(1.0f, 1.0f);
glDisable(GL_BLEND);
MEM_freeN(display_buffer);
}
}
RE_ReleaseResultImage(re);
}
/* Draw given image buffer on a screen using GLSL for display transform */
void glaDrawImBuf_glsl(ImBuf *ibuf, float x, float y, int zoomfilter,
ColorManagedViewSettings *view_settings,
ColorManagedDisplaySettings *display_settings)
{
bool force_fallback = false;
bool need_fallback = true;
/* Early out */
if (ibuf->rect == NULL && ibuf->rect_float == NULL)
return;
/* Single channel images could not be transformed using GLSL yet */
force_fallback |= ibuf->channels == 1;
/* If user decided not to use GLSL, fallback to glaDrawPixelsAuto */
force_fallback |= (U.image_draw_method != IMAGE_DRAW_METHOD_GLSL);
/* Try to draw buffer using GLSL display transform */
if (force_fallback == false) {
int ok;
if (ibuf->rect_float) {
if (ibuf->float_colorspace) {
ok = IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings,
ibuf->float_colorspace,
ibuf->dither, true);
}
else {
ok = IMB_colormanagement_setup_glsl_draw(view_settings, display_settings,
ibuf->dither, true);
}
}
else {
ok = IMB_colormanagement_setup_glsl_draw_from_space(view_settings, display_settings,
ibuf->rect_colorspace,
ibuf->dither, false);
}
if (ok) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(1.0, 1.0, 1.0, 1.0);
if (ibuf->rect_float) {
int format = 0;
if (ibuf->channels == 3)
format = GL_RGB;
else if (ibuf->channels == 4)
format = GL_RGBA;
else
BLI_assert(!"Incompatible number of channels for GLSL display");
if (format != 0) {
glaDrawPixelsTex(x, y, ibuf->x, ibuf->y, format, GL_FLOAT,
zoomfilter, ibuf->rect_float);
}
}
else if (ibuf->rect) {
/* ibuf->rect is always RGBA */
glaDrawPixelsTex(x, y, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE,
zoomfilter, ibuf->rect);
}
IMB_colormanagement_finish_glsl_draw();
need_fallback = false;
}
}
/* In case GLSL failed or not usable, fallback to glaDrawPixelsAuto */
if (need_fallback) {
unsigned char *display_buffer;
void *cache_handle;
display_buffer = IMB_display_buffer_acquire(ibuf, view_settings, display_settings, &cache_handle);
if (display_buffer)
glaDrawPixelsAuto(x, y, ibuf->x, ibuf->y, GL_RGBA, GL_UNSIGNED_BYTE,
zoomfilter, display_buffer);
IMB_display_buffer_release(cache_handle);
}
}
