void GPU_shader_uniform_texture(GPUShader *UNUSED(shader), int location, GPUTexture *tex)
{
GLenum arbnumber;
int number = GPU_texture_bound_number(tex);
int bindcode = GPU_texture_opengl_bindcode(tex);
int target = GPU_texture_target(tex);
if (number >= GPU_max_textures()) {
fprintf(stderr, "Not enough texture slots.\n");
return;
}
if (number == -1)
return;
if (location == -1)
return;
GPU_ASSERT_NO_GL_ERRORS("Pre Uniform Texture");
arbnumber = (GLenum)((GLuint)GL_TEXTURE0 + number);
if (number != 0) glActiveTexture(arbnumber);
if (bindcode != 0)
glBindTexture(target, bindcode);
else
GPU_invalid_tex_bind(target);
glUniform1i(location, number);
glEnable(target);
if (number != 0) glActiveTexture(GL_TEXTURE0);
GPU_ASSERT_NO_GL_ERRORS("Post Uniform Texture");
}
int GPU_framebuffer_texture_attach(GPUFrameBuffer *fb, GPUTexture *tex, int slot, char err_out[256])
{
GLenum attachment;
GLenum error;
if (slot >= GPU_FB_MAX_SLOTS) {
fprintf(stderr,
"Attaching to index %d framebuffer slot unsupported. "
"Use at most %d\n", slot, GPU_FB_MAX_SLOTS);
return 0;
}
if ((G.debug & G_DEBUG)) {
if (GPU_texture_bound_number(tex) != -1) {
fprintf(stderr,
"Feedback loop warning!: "
"Attempting to attach texture to framebuffer while still bound to texture unit for drawing!\n");
}
}
if (GPU_texture_depth(tex))
attachment = GL_DEPTH_ATTACHMENT_EXT;
else
attachment = GL_COLOR_ATTACHMENT0_EXT + slot;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb->object);
GG.currentfb = fb->object;
/* Clean glError buffer. */
while (glGetError() != GL_NO_ERROR) {}
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, attachment,
GPU_texture_target(tex), GPU_texture_opengl_bindcode(tex), 0);
error = glGetError();
if (error == GL_INVALID_OPERATION) {
GPU_framebuffer_restore();
gpu_print_framebuffer_error(error, err_out);
return 0;
}
if (GPU_texture_depth(tex))
fb->depthtex = tex;
else
fb->colortex[slot] = tex;
GPU_texture_framebuffer_set(tex, fb, slot);
return 1;
}
static void wm_draw_offscreen_texture_parameters(GPUOffScreen *offscreen)
{
/* Setup offscreen color texture for drawing. */
GPUTexture *texture = GPU_offscreen_color_texture(offscreen);
/* We don't support multisample textures here. */
BLI_assert(GPU_texture_target(texture) == GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, GPU_texture_opengl_bindcode(texture));
/* No mipmaps or filtering. */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
/* GL_TEXTURE_BASE_LEVEL = 0 by default */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
}
static PyObject *bpygpu_offscreen_color_texture_get(BPyGPUOffScreen *self, void *UNUSED(type))
{
BPY_GPU_OFFSCREEN_CHECK_OBJ(self);
GPUTexture *texture = GPU_offscreen_color_texture(self->ofs);
return PyLong_FromLong(GPU_texture_opengl_bindcode(texture));
}
static int rna_Image_bindcode_get(PointerRNA *ptr)
{
Image *ima = (Image *)ptr->data;
GPUTexture *tex = ima->gputexture[TEXTARGET_TEXTURE_2D];
return (tex) ? GPU_texture_opengl_bindcode(tex) : 0;
}
void wm_draw_region_blend(ARegion *ar, int view, bool blend)
{
if (!ar->draw_buffer) {
return;
}
/* Alpha is always 1, except when blend timer is running. */
float alpha = ED_region_blend_alpha(ar);
if (alpha <= 0.0f) {
return;
}
if (!blend) {
alpha = 1.0f;
}
/* setup actual texture */
GPUTexture *texture = wm_draw_region_texture(ar, view);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, GPU_texture_opengl_bindcode(texture));
/* wmOrtho for the screen has this same offset */
const float halfx = GLA_PIXEL_OFS / (BLI_rcti_size_x(&ar->winrct) + 1);
const float halfy = GLA_PIXEL_OFS / (BLI_rcti_size_y(&ar->winrct) + 1);
if (blend) {
/* GL_ONE because regions drawn offscreen have premultiplied alpha. */
GPU_blend(true);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
GPUShader *shader = GPU_shader_get_builtin_shader(GPU_SHADER_2D_IMAGE_RECT_COLOR);
GPU_shader_bind(shader);
rcti rect_geo = ar->winrct;
rect_geo.xmax += 1;
rect_geo.ymax += 1;
rctf rect_tex;
rect_tex.xmin = halfx;
rect_tex.ymin = halfy;
rect_tex.xmax = 1.0f + halfx;
rect_tex.ymax = 1.0f + halfy;
float alpha_easing = 1.0f - alpha;
alpha_easing = 1.0f - alpha_easing * alpha_easing;
/* Slide vertical panels */
float ofs_x = BLI_rcti_size_x(&ar->winrct) * (1.0f - alpha_easing);
if (ar->alignment == RGN_ALIGN_RIGHT) {
rect_geo.xmin += ofs_x;
rect_tex.xmax *= alpha_easing;
alpha = 1.0f;
}
else if (ar->alignment == RGN_ALIGN_LEFT) {
rect_geo.xmax -= ofs_x;
rect_tex.xmin += 1.0f - alpha_easing;
alpha = 1.0f;
}
glUniform1i(GPU_shader_get_uniform_ensure(shader, "image"), 0);
glUniform4f(GPU_shader_get_uniform_ensure(shader, "rect_icon"),
rect_tex.xmin,
rect_tex.ymin,
rect_tex.xmax,
rect_tex.ymax);
glUniform4f(GPU_shader_get_uniform_ensure(shader, "rect_geom"),
rect_geo.xmin,
rect_geo.ymin,
rect_geo.xmax,
rect_geo.ymax);
glUniform4f(
GPU_shader_get_builtin_uniform(shader, GPU_UNIFORM_COLOR), alpha, alpha, alpha, alpha);
GPU_draw_primitive(GPU_PRIM_TRI_STRIP, 4);
glBindTexture(GL_TEXTURE_2D, 0);
if (blend) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GPU_blend(false);
}
}
int GPU_offscreen_color_texture(const GPUOffScreen *ofs)
{
return GPU_texture_opengl_bindcode(ofs->color);
}
