void GPU_invalid_tex_free(void)
{
if (GG.invalid_tex_1D)
GPU_texture_free(GG.invalid_tex_1D);
if (GG.invalid_tex_2D)
GPU_texture_free(GG.invalid_tex_2D);
if (GG.invalid_tex_3D)
GPU_texture_free(GG.invalid_tex_3D);
}
void GPU_offscreen_free(GPUOffScreen *ofs)
{
if (ofs->fb)
GPU_framebuffer_free(ofs->fb);
if (ofs->color)
GPU_texture_free(ofs->color);
if (ofs->depth)
GPU_texture_free(ofs->depth);
MEM_freeN(ofs);
}
static void icon_preview_endjob(void *customdata)
{
IconPreview *ip = customdata;
if (ip->id) {
if (GS(ip->id->name) == ID_BR)
WM_main_add_notifier(NC_BRUSH | NA_EDITED, ip->id);
#if 0
if (GS(ip->id->name) == ID_MA) {
Material *ma = (Material *)ip->id;
PreviewImage *prv_img = ma->preview;
int i;
/* signal to gpu texture */
for (i = 0; i < NUM_ICON_SIZES; ++i) {
if (prv_img->gputexture[i]) {
GPU_texture_free(prv_img->gputexture[i]);
prv_img->gputexture[i] = NULL;
WM_main_add_notifier(NC_MATERIAL|ND_SHADING_DRAW, ip->id);
}
}
}
#endif
}
}
void GPU_fx_compositor_setup_XRay_pass(GPUFX *fx, bool do_xray)
{
char err_out[256];
if (do_xray) {
if (!fx->depth_buffer_xray && !(fx->depth_buffer_xray = GPU_texture_create_depth(fx->gbuffer_dim[0], fx->gbuffer_dim[1], err_out))) {
printf("%.256s\n", err_out);
cleanup_fx_gl_data(fx, true);
return;
}
}
else {
if (fx->depth_buffer_xray) {
GPU_framebuffer_texture_detach(fx->depth_buffer_xray);
GPU_texture_free(fx->depth_buffer_xray);
fx->depth_buffer_xray = NULL;
}
return;
}
GPU_framebuffer_texture_detach(fx->depth_buffer);
/* first depth buffer, because system assumes read/write buffers */
if(!GPU_framebuffer_texture_attach(fx->gbuffer, fx->depth_buffer_xray, 0, err_out))
printf("%.256s\n", err_out);
}
void BKE_previewimg_clear_single(struct PreviewImage *prv, enum eIconSizes size)
{
MEM_SAFE_FREE(prv->rect[size]);
if (prv->gputexture[size]) {
GPU_texture_free(prv->gputexture[size]);
}
prv->h[size] = prv->w[size] = 0;
prv->flag[size] |= PRV_CHANGED;
prv->flag[size] &= ~PRV_USER_EDITED;
prv->changed_timestamp[size] = 0;
}
static void GPU_inputs_free(ListBase *inputs)
{
GPUInput *input;
for (input=inputs->first; input; input=input->next) {
if (input->link)
GPU_node_link_free(input->link);
else if (input->tex && !input->dynamictex)
GPU_texture_free(input->tex);
}
BLI_freelistN(inputs);
}
static void unbind_shader(SmokeDomainSettings *sds, GPUTexture *tex_spec, bool use_fire)
{
GPU_shader_unbind();
GPU_texture_unbind(sds->tex);
if (use_fire) {
GPU_texture_unbind(sds->tex_flame);
GPU_texture_unbind(tex_spec);
GPU_texture_free(tex_spec);
}
else {
GPU_texture_unbind(sds->tex_shadow);
}
}
static void gpu_material_free_single(GPUMaterial *material)
{
/* Cancel / wait any pending lazy compilation. */
DRW_deferred_shader_remove(material);
GPU_pass_free_nodes(&material->nodes);
GPU_inputs_free(&material->inputs);
if (material->pass != NULL) {
GPU_pass_release(material->pass);
}
if (material->ubo != NULL) {
GPU_uniformbuffer_free(material->ubo);
}
if (material->sss_tex_profile != NULL) {
GPU_texture_free(material->sss_tex_profile);
}
if (material->sss_profile != NULL) {
GPU_uniformbuffer_free(material->sss_profile);
}
if (material->coba_tex != NULL) {
GPU_texture_free(material->coba_tex);
}
}
void BKE_previewimg_freefunc(void *link)
{
PreviewImage *prv = (PreviewImage *)link;
if (prv) {
int i;
for (i = 0; i < NUM_ICON_SIZES; ++i) {
if (prv->rect[i]) {
MEM_freeN(prv->rect[i]);
}
if (prv->gputexture[i])
GPU_texture_free(prv->gputexture[i]);
}
MEM_freeN(prv);
}
}
static void cleanup_fx_dof_buffers(GPUFX *fx)
{
if (fx->dof_near_coc_blurred_buffer) {
GPU_texture_free(fx->dof_near_coc_blurred_buffer);
fx->dof_near_coc_blurred_buffer = NULL;
}
if (fx->dof_near_coc_buffer) {
GPU_texture_free(fx->dof_near_coc_buffer);
fx->dof_near_coc_buffer = NULL;
}
if (fx->dof_near_coc_final_buffer) {
GPU_texture_free(fx->dof_near_coc_final_buffer);
fx->dof_near_coc_final_buffer = NULL;
}
if (fx->dof_half_downsampled) {
GPU_texture_free(fx->dof_half_downsampled);
fx->dof_half_downsampled = NULL;
}
if (fx->dof_nearfar_coc[0]) {
int i;
for (i = 0; i < 6; i++) {
GPU_texture_free(fx->dof_nearfar_coc[i]);
fx->dof_nearfar_coc[i] = NULL;
}
}
if (fx->dof_near_blur) {
GPU_texture_free(fx->dof_near_blur);
fx->dof_near_blur = NULL;
}
if (fx->dof_far_blur) {
GPU_texture_free(fx->dof_far_blur);
fx->dof_far_blur = NULL;
}
if (fx->dof_concentric_samples_tex) {
GPU_texture_free(fx->dof_concentric_samples_tex);
fx->dof_concentric_samples_tex = NULL;
}
}
static void cleanup_fx_dof_buffers(GPUFX *fx)
{
if (fx->dof_near_coc_blurred_buffer) {
GPU_texture_free(fx->dof_near_coc_blurred_buffer);
fx->dof_near_coc_blurred_buffer = NULL;
}
if (fx->dof_near_coc_buffer) {
GPU_texture_free(fx->dof_near_coc_buffer);
fx->dof_near_coc_buffer = NULL;
}
if (fx->dof_near_coc_final_buffer) {
GPU_texture_free(fx->dof_near_coc_final_buffer);
fx->dof_near_coc_final_buffer = NULL;
}
if (fx->dof_half_downsampled_near) {
GPU_texture_free(fx->dof_half_downsampled_near);
fx->dof_half_downsampled_near = NULL;
}
if (fx->dof_half_downsampled_far) {
GPU_texture_free(fx->dof_half_downsampled_far);
fx->dof_half_downsampled_far = NULL;
}
if (fx->dof_nearfar_coc) {
GPU_texture_free(fx->dof_nearfar_coc);
fx->dof_nearfar_coc = NULL;
}
if (fx->dof_near_blur) {
GPU_texture_free(fx->dof_near_blur);
fx->dof_near_blur = NULL;
}
if (fx->dof_far_blur) {
GPU_texture_free(fx->dof_far_blur);
fx->dof_far_blur = NULL;
}
}
static void icon_preview_endjob(void *customdata)
{
IconPreview *ip = customdata;
if (ip->id) {
if (GS(ip->id->name) == ID_BR) {
WM_main_add_notifier(NC_BRUSH | NA_EDITED, ip->id);
}
#if 0
if (GS(ip->id->name) == ID_MA) {
Material *ma = (Material *)ip->id;
PreviewImage *prv_img = ma->preview;
int i;
/* signal to gpu texture */
for (i = 0; i < NUM_ICON_SIZES; ++i) {
if (prv_img->gputexture[i]) {
GPU_texture_free(prv_img->gputexture[i]);
prv_img->gputexture[i] = NULL;
WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, ip->id);
}
}
}
#endif
}
if (ip->owner) {
PreviewImage *prv_img = ip->owner;
prv_img->tag &= ~PRV_TAG_DEFFERED_RENDERING;
if (prv_img->tag & PRV_TAG_DEFFERED_DELETE) {
BLI_assert(prv_img->tag & PRV_TAG_DEFFERED);
BKE_previewimg_cached_release_pointer(prv_img);
}
}
}
static void cleanup_fx_gl_data(GPUFX *fx, bool do_fbo)
{
if (fx->color_buffer) {
GPU_framebuffer_texture_detach(fx->color_buffer);
GPU_texture_free(fx->color_buffer);
fx->color_buffer = NULL;
}
if (fx->color_buffer_sec) {
GPU_framebuffer_texture_detach(fx->color_buffer_sec);
GPU_texture_free(fx->color_buffer_sec);
fx->color_buffer_sec = NULL;
}
if (fx->depth_buffer) {
GPU_framebuffer_texture_detach(fx->depth_buffer);
GPU_texture_free(fx->depth_buffer);
fx->depth_buffer = NULL;
}
if (fx->depth_buffer_xray) {
GPU_framebuffer_texture_detach(fx->depth_buffer_xray);
GPU_texture_free(fx->depth_buffer_xray);
fx->depth_buffer_xray = NULL;
}
cleanup_fx_dof_buffers(fx);
if (fx->ssao_concentric_samples_tex) {
GPU_texture_free(fx->ssao_concentric_samples_tex);
fx->ssao_concentric_samples_tex = NULL;
}
if (fx->jitter_buffer && do_fbo) {
GPU_texture_free(fx->jitter_buffer);
fx->jitter_buffer = NULL;
}
if (fx->gbuffer && do_fbo) {
GPU_framebuffer_free(fx->gbuffer);
fx->gbuffer = NULL;
}
}
bool GPU_fx_compositor_initialize_passes(
GPUFX *fx, const rcti *rect, const rcti *scissor_rect,
const GPUFXSettings *fx_settings)
{
int w = BLI_rcti_size_x(rect), h = BLI_rcti_size_y(rect);
char err_out[256];
int num_passes = 0;
char fx_flag;
fx->effects = 0;
if (!fx_settings) {
cleanup_fx_gl_data(fx, true);
return false;
}
fx_flag = fx_settings->fx_flag;
/* disable effects if no options passed for them */
if (!fx_settings->dof) {
fx_flag &= ~GPU_FX_FLAG_DOF;
}
if (!fx_settings->ssao || fx_settings->ssao->samples < 1) {
fx_flag &= ~GPU_FX_FLAG_SSAO;
}
if (!fx_flag) {
cleanup_fx_gl_data(fx, true);
return false;
}
/* scissor is missing when drawing offscreen, in that case, dimensions match exactly. In opposite case
* add one to match viewport dimensions */
if (scissor_rect) {
w++, h++;
}
fx->num_passes = 0;
/* dof really needs a ping-pong buffer to work */
if (fx_flag & GPU_FX_FLAG_DOF)
num_passes++;
if (fx_flag & GPU_FX_FLAG_SSAO)
num_passes++;
if (!fx->gbuffer)
fx->gbuffer = GPU_framebuffer_create();
/* try creating the jitter texture */
if (!fx->jitter_buffer)
fx->jitter_buffer = create_jitter_texture();
if (!fx->gbuffer)
return false;
/* check if color buffers need recreation */
if (!fx->color_buffer || !fx->depth_buffer || w != fx->gbuffer_dim[0] || h != fx->gbuffer_dim[1]) {
cleanup_fx_gl_data(fx, false);
if (!(fx->color_buffer = GPU_texture_create_2D(w, h, NULL, GPU_HDR_NONE, err_out))) {
printf(".256%s\n", err_out);
cleanup_fx_gl_data(fx, true);
return false;
}
if (!(fx->depth_buffer = GPU_texture_create_depth(w, h, err_out))) {
printf("%.256s\n", err_out);
cleanup_fx_gl_data(fx, true);
return false;
}
}
if (fx_flag & GPU_FX_FLAG_SSAO) {
if (fx_settings->ssao->samples != fx->ssao_sample_count || !fx->ssao_concentric_samples_tex) {
if (fx_settings->ssao->samples < 1)
fx_settings->ssao->samples = 1;
fx->ssao_sample_count = fx_settings->ssao->samples;
if (fx->ssao_concentric_samples_tex) {
GPU_texture_free(fx->ssao_concentric_samples_tex);
}
fx->ssao_concentric_samples_tex = create_spiral_sample_texture(fx_settings->ssao->samples);
}
}
else {
if (fx->ssao_concentric_samples_tex) {
GPU_texture_free(fx->ssao_concentric_samples_tex);
fx->ssao_concentric_samples_tex = NULL;
}
}
/* create textures for dof effect */
if (fx_flag & GPU_FX_FLAG_DOF) {
if (!fx->dof_near_coc_buffer || !fx->dof_near_coc_blurred_buffer || !fx->dof_near_coc_final_buffer) {
fx->dof_downsampled_w = w / 4;
fx->dof_downsampled_h = h / 4;
if (!(fx->dof_near_coc_buffer = GPU_texture_create_2D(
fx->dof_downsampled_w, fx->dof_downsampled_h, NULL, GPU_HDR_NONE, err_out)))
{
printf("%.256s\n", err_out);
cleanup_fx_gl_data(fx, true);
return false;
}
if (!(fx->dof_near_coc_blurred_buffer = GPU_texture_create_2D(
fx->dof_downsampled_w, fx->dof_downsampled_h, NULL, GPU_HDR_NONE, err_out)))
{
printf("%.256s\n", err_out);
cleanup_fx_gl_data(fx, true);
return false;
}
if (!(fx->dof_near_coc_final_buffer = GPU_texture_create_2D(
fx->dof_downsampled_w, fx->dof_downsampled_h, NULL, GPU_HDR_NONE, err_out)))
{
printf("%.256s\n", err_out);
cleanup_fx_gl_data(fx, true);
return false;
}
}
}
else {
/* cleanup unnecessary buffers */
cleanup_fx_dof_buffers(fx);
}
/* we need to pass data between shader stages, allocate an extra color buffer */
if (num_passes > 1) {
if(!fx->color_buffer_sec) {
if (!(fx->color_buffer_sec = GPU_texture_create_2D(w, h, NULL, GPU_HDR_NONE, err_out))) {
printf(".256%s\n", err_out);
cleanup_fx_gl_data(fx, true);
return false;
}
}
}
else {
if (fx->color_buffer_sec) {
GPU_framebuffer_texture_detach(fx->color_buffer_sec);
GPU_texture_free(fx->color_buffer_sec);
fx->color_buffer_sec = NULL;
}
}
/* bind the buffers */
/* first depth buffer, because system assumes read/write buffers */
if(!GPU_framebuffer_texture_attach(fx->gbuffer, fx->depth_buffer, 0, err_out))
printf("%.256s\n", err_out);
if(!GPU_framebuffer_texture_attach(fx->gbuffer, fx->color_buffer, 0, err_out))
printf("%.256s\n", err_out);
if(!GPU_framebuffer_check_valid(fx->gbuffer, err_out))
printf("%.256s\n", err_out);
GPU_texture_bind_as_framebuffer(fx->color_buffer);
/* enable scissor test. It's needed to ensure sculpting works correctly */
if (scissor_rect) {
int w_sc = BLI_rcti_size_x(scissor_rect) + 1;
int h_sc = BLI_rcti_size_y(scissor_rect) + 1;
glPushAttrib(GL_SCISSOR_BIT);
glEnable(GL_SCISSOR_TEST);
glScissor(scissor_rect->xmin - rect->xmin, scissor_rect->ymin - rect->ymin,
w_sc, h_sc);
fx->restore_stencil = true;
}
else {
fx->restore_stencil = false;
}
fx->effects = fx_flag;
if (fx_settings)
fx->settings = *fx_settings;
fx->gbuffer_dim[0] = w;
fx->gbuffer_dim[1] = h;
fx->num_passes = num_passes;
return true;
}
void draw_smoke_volume(SmokeDomainSettings *sds, Object *ob,
GPUTexture *tex, const float min[3], const float max[3],
const int res[3], float dx, float UNUSED(base_scale), const float viewnormal[3],
GPUTexture *tex_shadow, GPUTexture *tex_flame)
{
const float ob_sizei[3] = {
1.0f / fabsf(ob->size[0]),
1.0f / fabsf(ob->size[1]),
1.0f / fabsf(ob->size[2])};
int i, j, k, n, good_index;
float d /*, d0 */ /* UNUSED */, dd, ds;
float (*points)[3] = NULL;
int numpoints = 0;
float cor[3] = {1.0f, 1.0f, 1.0f};
int gl_depth = 0, gl_blend = 0;
int use_fire = (sds->active_fields & SM_ACTIVE_FIRE);
/* draw slices of smoke is adapted from c++ code authored
* by: Johannes Schmid and Ingemar Rask, 2006, [email protected] */
float cv[][3] = {
{1.0f, 1.0f, 1.0f}, {-1.0f, 1.0f, 1.0f}, {-1.0f, -1.0f, 1.0f}, {1.0f, -1.0f, 1.0f},
{1.0f, 1.0f, -1.0f}, {-1.0f, 1.0f, -1.0f}, {-1.0f, -1.0f, -1.0f}, {1.0f, -1.0f, -1.0f}
};
/* edges have the form edges[n][0][xyz] + t*edges[n][1][xyz] */
float edges[12][2][3] = {
{{1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{-1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{-1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
{{1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, 1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, -1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, -1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, 1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}}
};
unsigned char *spec_data;
float *spec_pixels;
GPUTexture *tex_spec;
GPUProgram *smoke_program;
int progtype = (sds->active_fields & SM_ACTIVE_COLORS) ? GPU_PROGRAM_SMOKE_COLORED : GPU_PROGRAM_SMOKE;
float size[3];
if (!tex) {
printf("Could not allocate 3D texture for 3D View smoke drawing.\n");
return;
}
#ifdef DEBUG_DRAW_TIME
TIMEIT_START(draw);
#endif
/* generate flame spectrum texture */
#define SPEC_WIDTH 256
#define FIRE_THRESH 7
#define MAX_FIRE_ALPHA 0.06f
#define FULL_ON_FIRE 100
spec_data = malloc(SPEC_WIDTH * 4 * sizeof(unsigned char));
flame_get_spectrum(spec_data, SPEC_WIDTH, 1500, 3000);
spec_pixels = malloc(SPEC_WIDTH * 4 * 16 * 16 * sizeof(float));
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
for (k = 0; k < SPEC_WIDTH; k++) {
int index = (j * SPEC_WIDTH * 16 + i * SPEC_WIDTH + k) * 4;
if (k >= FIRE_THRESH) {
spec_pixels[index] = ((float)spec_data[k * 4]) / 255.0f;
spec_pixels[index + 1] = ((float)spec_data[k * 4 + 1]) / 255.0f;
spec_pixels[index + 2] = ((float)spec_data[k * 4 + 2]) / 255.0f;
spec_pixels[index + 3] = MAX_FIRE_ALPHA * (
(k > FULL_ON_FIRE) ? 1.0f : (k - FIRE_THRESH) / ((float)FULL_ON_FIRE - FIRE_THRESH));
}
else {
spec_pixels[index] = spec_pixels[index + 1] = spec_pixels[index + 2] = spec_pixels[index + 3] = 0.0f;
}
}
}
}
tex_spec = GPU_texture_create_1D(SPEC_WIDTH, spec_pixels, NULL);
#undef SPEC_WIDTH
#undef FIRE_THRESH
#undef MAX_FIRE_ALPHA
#undef FULL_ON_FIRE
sub_v3_v3v3(size, max, min);
/* maxx, maxy, maxz */
cv[0][0] = max[0];
cv[0][1] = max[1];
cv[0][2] = max[2];
/* minx, maxy, maxz */
cv[1][0] = min[0];
cv[1][1] = max[1];
cv[1][2] = max[2];
/* minx, miny, maxz */
cv[2][0] = min[0];
cv[2][1] = min[1];
cv[2][2] = max[2];
/* maxx, miny, maxz */
cv[3][0] = max[0];
cv[3][1] = min[1];
cv[3][2] = max[2];
/* maxx, maxy, minz */
cv[4][0] = max[0];
cv[4][1] = max[1];
cv[4][2] = min[2];
/* minx, maxy, minz */
cv[5][0] = min[0];
cv[5][1] = max[1];
cv[5][2] = min[2];
/* minx, miny, minz */
cv[6][0] = min[0];
cv[6][1] = min[1];
cv[6][2] = min[2];
/* maxx, miny, minz */
cv[7][0] = max[0];
cv[7][1] = min[1];
cv[7][2] = min[2];
copy_v3_v3(edges[0][0], cv[4]); /* maxx, maxy, minz */
copy_v3_v3(edges[1][0], cv[5]); /* minx, maxy, minz */
copy_v3_v3(edges[2][0], cv[6]); /* minx, miny, minz */
copy_v3_v3(edges[3][0], cv[7]); /* maxx, miny, minz */
copy_v3_v3(edges[4][0], cv[3]); /* maxx, miny, maxz */
copy_v3_v3(edges[5][0], cv[2]); /* minx, miny, maxz */
copy_v3_v3(edges[6][0], cv[6]); /* minx, miny, minz */
copy_v3_v3(edges[7][0], cv[7]); /* maxx, miny, minz */
copy_v3_v3(edges[8][0], cv[1]); /* minx, maxy, maxz */
copy_v3_v3(edges[9][0], cv[2]); /* minx, miny, maxz */
copy_v3_v3(edges[10][0], cv[6]); /* minx, miny, minz */
copy_v3_v3(edges[11][0], cv[5]); /* minx, maxy, minz */
// printf("size x: %f, y: %f, z: %f\n", size[0], size[1], size[2]);
// printf("min[2]: %f, max[2]: %f\n", min[2], max[2]);
edges[0][1][2] = size[2];
edges[1][1][2] = size[2];
edges[2][1][2] = size[2];
edges[3][1][2] = size[2];
edges[4][1][1] = size[1];
edges[5][1][1] = size[1];
edges[6][1][1] = size[1];
edges[7][1][1] = size[1];
edges[8][1][0] = size[0];
edges[9][1][0] = size[0];
edges[10][1][0] = size[0];
edges[11][1][0] = size[0];
glGetBooleanv(GL_BLEND, (GLboolean *)&gl_blend);
glGetBooleanv(GL_DEPTH_TEST, (GLboolean *)&gl_depth);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
/* find cube vertex that is closest to the viewer */
for (i = 0; i < 8; i++) {
float x, y, z;
x = cv[i][0] - viewnormal[0] * size[0] * 0.5f;
y = cv[i][1] - viewnormal[1] * size[1] * 0.5f;
z = cv[i][2] - viewnormal[2] * size[2] * 0.5f;
if ((x >= min[0]) && (x <= max[0]) &&
(y >= min[1]) && (y <= max[1]) &&
(z >= min[2]) && (z <= max[2]))
{
break;
}
}
if (i >= 8) {
/* fallback, avoid using buffer over-run */
i = 0;
}
// printf("i: %d\n", i);
// printf("point %f, %f, %f\n", cv[i][0], cv[i][1], cv[i][2]);
smoke_program = GPU_shader_get_builtin_program(progtype);
if (smoke_program) {
GPU_program_bind(smoke_program);
/* cell spacing */
GPU_program_parameter_4f(smoke_program, 0, dx, dx, dx, 1.0);
/* custom parameter for smoke style (higher = thicker) */
if (sds->active_fields & SM_ACTIVE_COLORS)
GPU_program_parameter_4f(smoke_program, 1, 1.0, 1.0, 1.0, 10.0);
else
GPU_program_parameter_4f(smoke_program, 1, sds->active_color[0], sds->active_color[1], sds->active_color[2], 10.0);
}
else
printf("Your gfx card does not support 3D View smoke drawing.\n");
GPU_texture_bind(tex, 0);
if (tex_shadow)
GPU_texture_bind(tex_shadow, 1);
else
printf("No volume shadow\n");
if (tex_flame) {
GPU_texture_bind(tex_flame, 2);
GPU_texture_bind(tex_spec, 3);
}
if (!GPU_non_power_of_two_support()) {
cor[0] = (float)res[0] / (float)power_of_2_max_u(res[0]);
cor[1] = (float)res[1] / (float)power_of_2_max_u(res[1]);
cor[2] = (float)res[2] / (float)power_of_2_max_u(res[2]);
}
cor[0] /= size[0];
cor[1] /= size[1];
cor[2] /= size[2];
/* our slices are defined by the plane equation a*x + b*y +c*z + d = 0
* (a,b,c), the plane normal, are given by viewdir
* d is the parameter along the view direction. the first d is given by
* inserting previously found vertex into the plane equation */
/* d0 = (viewnormal[0]*cv[i][0] + viewnormal[1]*cv[i][1] + viewnormal[2]*cv[i][2]); */ /* UNUSED */
ds = (fabsf(viewnormal[0]) * size[0] + fabsf(viewnormal[1]) * size[1] + fabsf(viewnormal[2]) * size[2]);
dd = max_fff(sds->global_size[0], sds->global_size[1], sds->global_size[2]) / 128.f;
n = 0;
good_index = i;
// printf("d0: %f, dd: %f, ds: %f\n\n", d0, dd, ds);
points = MEM_callocN(sizeof(*points) * 12, "smoke_points_preview");
while (1) {
float p0[3];
float tmp_point[3], tmp_point2[3];
if (dd * (float)n > ds)
break;
copy_v3_v3(tmp_point, viewnormal);
mul_v3_fl(tmp_point, -dd * ((ds / dd) - (float)n));
add_v3_v3v3(tmp_point2, cv[good_index], tmp_point);
d = dot_v3v3(tmp_point2, viewnormal);
// printf("my d: %f\n", d);
/* intersect_edges returns the intersection points of all cube edges with
* the given plane that lie within the cube */
numpoints = intersect_edges(points, viewnormal[0], viewnormal[1], viewnormal[2], -d, edges);
// printf("points: %d\n", numpoints);
if (numpoints > 2) {
copy_v3_v3(p0, points[0]);
/* sort points to get a convex polygon */
for (i = 1; i < numpoints - 1; i++) {
for (j = i + 1; j < numpoints; j++) {
if (!convex(p0, viewnormal, points[j], points[i])) {
swap_v3_v3(points[i], points[j]);
}
}
}
/* render fire slice */
if (use_fire) {
if (GLEW_VERSION_1_4)
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
else
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
GPU_program_parameter_4f(smoke_program, 2, 1.0, 0.0, 0.0, 0.0);
glBegin(GL_POLYGON);
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < numpoints; i++) {
glTexCoord3d((points[i][0] - min[0]) * cor[0],
(points[i][1] - min[1]) * cor[1],
(points[i][2] - min[2]) * cor[2]);
glVertex3f(points[i][0] * ob_sizei[0],
points[i][1] * ob_sizei[1],
points[i][2] * ob_sizei[2]);
}
glEnd();
}
/* render smoke slice */
if (GLEW_VERSION_1_4)
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
else
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GPU_program_parameter_4f(smoke_program, 2, -1.0, 0.0, 0.0, 0.0);
glBegin(GL_POLYGON);
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < numpoints; i++) {
glTexCoord3d((points[i][0] - min[0]) * cor[0],
(points[i][1] - min[1]) * cor[1],
(points[i][2] - min[2]) * cor[2]);
glVertex3f(points[i][0] * ob_sizei[0],
points[i][1] * ob_sizei[1],
points[i][2] * ob_sizei[2]);
}
glEnd();
}
n++;
}
#ifdef DEBUG_DRAW_TIME
printf("Draw Time: %f\n", (float)TIMEIT_VALUE(draw));
TIMEIT_END(draw);
#endif
if (tex_shadow)
GPU_texture_unbind(tex_shadow);
GPU_texture_unbind(tex);
if (tex_flame) {
GPU_texture_unbind(tex_flame);
GPU_texture_unbind(tex_spec);
}
GPU_texture_free(tex_spec);
free(spec_data);
free(spec_pixels);
if (smoke_program)
GPU_program_unbind(smoke_program);
MEM_freeN(points);
if (!gl_blend) {
glDisable(GL_BLEND);
}
if (gl_depth) {
glEnable(GL_DEPTH_TEST);
}
}
GPUTexture *GPU_texture_create_3D(int w, int h, int depth, int channels, float *fpixels)
{
GPUTexture *tex;
GLenum type, format, internalformat;
void *pixels = NULL;
float vfBorderColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
if (!GLEW_VERSION_1_2)
return NULL;
tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
tex->w = w;
tex->h = h;
tex->depth = depth;
tex->number = -1;
tex->refcount = 1;
tex->target = GL_TEXTURE_3D;
glGenTextures(1, &tex->bindcode);
if (!tex->bindcode) {
fprintf(stderr, "GPUTexture: texture create failed: %d\n",
(int)glGetError());
GPU_texture_free(tex);
return NULL;
}
if (!GPU_non_power_of_two_support()) {
tex->w = power_of_2_max_i(tex->w);
tex->h = power_of_2_max_i(tex->h);
tex->depth = power_of_2_max_i(tex->depth);
}
tex->number = 0;
glBindTexture(tex->target, tex->bindcode);
GPU_print_error("3D glBindTexture");
type = GL_FLOAT;
if (channels == 4) {
format = GL_RGBA;
internalformat = GL_RGBA;
}
else {
format = GL_RED;
internalformat = GL_INTENSITY;
}
//if (fpixels)
// pixels = GPU_texture_convert_pixels(w*h*depth, fpixels);
glTexImage3D(tex->target, 0, internalformat, tex->w, tex->h, tex->depth, 0, format, type, NULL);
GPU_print_error("3D glTexImage3D");
if (fpixels) {
if (!GPU_non_power_of_two_support() && (w != tex->w || h != tex->h || depth != tex->depth)) {
/* clear first to avoid unitialized pixels */
float *zero= MEM_callocN(sizeof(float)*tex->w*tex->h*tex->depth, "zero");
glTexSubImage3D(tex->target, 0, 0, 0, 0, tex->w, tex->h, tex->depth, format, type, zero);
MEM_freeN(zero);
}
glTexSubImage3D(tex->target, 0, 0, 0, 0, w, h, depth, format, type, fpixels);
GPU_print_error("3D glTexSubImage3D");
}
glTexParameterfv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, vfBorderColor);
GPU_print_error("3D GL_TEXTURE_BORDER_COLOR");
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GPU_print_error("3D GL_LINEAR");
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
GPU_print_error("3D GL_CLAMP_TO_BORDER");
if (pixels)
MEM_freeN(pixels);
GPU_texture_unbind(tex);
return tex;
}
static GPUTexture *GPU_texture_create_nD(int w, int h, int n, float *fpixels, int depth, char err_out[256])
{
GPUTexture *tex;
GLenum type, format, internalformat;
void *pixels = NULL;
if (depth && !GLEW_ARB_depth_texture)
return NULL;
tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
tex->w = w;
tex->h = h;
tex->number = -1;
tex->refcount = 1;
tex->target = (n == 1)? GL_TEXTURE_1D: GL_TEXTURE_2D;
tex->depth = depth;
glGenTextures(1, &tex->bindcode);
if (!tex->bindcode) {
if (err_out) {
BLI_snprintf(err_out, 256, "GPUTexture: texture create failed: %d",
(int)glGetError());
}
else {
fprintf(stderr, "GPUTexture: texture create failed: %d\n",
(int)glGetError());
}
GPU_texture_free(tex);
return NULL;
}
if (!GPU_non_power_of_two_support()) {
tex->w = power_of_2_max_i(tex->w);
tex->h = power_of_2_max_i(tex->h);
}
tex->number = 0;
glBindTexture(tex->target, tex->bindcode);
if (depth) {
type = GL_UNSIGNED_BYTE;
format = GL_DEPTH_COMPONENT;
internalformat = GL_DEPTH_COMPONENT;
}
else {
type = GL_UNSIGNED_BYTE;
format = GL_RGBA;
internalformat = GL_RGBA8;
if (fpixels)
pixels = GPU_texture_convert_pixels(w*h, fpixels);
}
if (tex->target == GL_TEXTURE_1D) {
glTexImage1D(tex->target, 0, internalformat, tex->w, 0, format, type, NULL);
if (fpixels) {
glTexSubImage1D(tex->target, 0, 0, w, format, type,
pixels ? pixels : fpixels);
if (tex->w > w)
GPU_glTexSubImageEmpty(tex->target, format, w, 0,
tex->w-w, 1);
}
}
else {
glTexImage2D(tex->target, 0, internalformat, tex->w, tex->h, 0,
format, type, NULL);
if (fpixels) {
glTexSubImage2D(tex->target, 0, 0, 0, w, h,
format, type, pixels ? pixels : fpixels);
if (tex->w > w)
GPU_glTexSubImageEmpty(tex->target, format, w, 0, tex->w-w, tex->h);
if (tex->h > h)
GPU_glTexSubImageEmpty(tex->target, format, 0, h, w, tex->h-h);
}
}
if (pixels)
MEM_freeN(pixels);
if (depth) {
glTexParameteri(tex->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(tex->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(tex->target, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(tex->target, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
glTexParameteri(tex->target, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
}
else {
glTexParameteri(tex->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(tex->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
if (tex->target != GL_TEXTURE_1D) {
/* CLAMP_TO_BORDER is an OpenGL 1.3 core feature */
GLenum wrapmode = (depth || tex->h == 1)? GL_CLAMP_TO_EDGE: GL_CLAMP_TO_BORDER;
glTexParameteri(tex->target, GL_TEXTURE_WRAP_S, wrapmode);
glTexParameteri(tex->target, GL_TEXTURE_WRAP_T, wrapmode);
#if 0
float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
#endif
}
else
glTexParameteri(tex->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
return tex;
}
GPUTexture *GPU_texture_create_3D(int w, int h, int depth, float *fpixels)
{
GPUTexture *tex;
GLenum type, format, internalformat;
void *pixels = NULL;
float vfBorderColor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
tex->w = w;
tex->h = h;
tex->depth = depth;
tex->number = -1;
tex->refcount = 1;
tex->target = GL_TEXTURE_3D;
glGenTextures(1, &tex->bindcode);
if (!tex->bindcode) {
fprintf(stderr, "GPUTexture: texture create failed: %d\n",
(int)glGetError());
GPU_texture_free(tex);
return NULL;
}
if (!GPU_non_power_of_two_support()) {
tex->w = larger_pow2(tex->w);
tex->h = larger_pow2(tex->h);
tex->depth = larger_pow2(tex->depth);
}
tex->number = 0;
glBindTexture(tex->target, tex->bindcode);
GPU_print_error("3D glBindTexture");
type = GL_FLOAT; // GL_UNSIGNED_BYTE
format = GL_RED;
internalformat = GL_INTENSITY;
//if (fpixels)
// pixels = GPU_texture_convert_pixels(w*h*depth, fpixels);
glTexImage3D(tex->target, 0, internalformat, tex->w, tex->h, tex->depth, 0, format, type, 0);
GPU_print_error("3D glTexImage3D");
if (fpixels) {
glTexSubImage3D(tex->target, 0, 0, 0, 0, w, h, depth, format, type, fpixels);
GPU_print_error("3D glTexSubImage3D");
}
glTexParameterfv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, vfBorderColor);
GPU_print_error("3D GL_TEXTURE_BORDER_COLOR");
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GPU_print_error("3D GL_LINEAR");
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
GPU_print_error("3D GL_CLAMP_TO_BORDER");
if (pixels)
MEM_freeN(pixels);
if (tex)
GPU_texture_unbind(tex);
return tex;
}
static GPUTexture *GPU_texture_create_nD(
int w, int h, int n, const float *fpixels, int depth,
GPUHDRType hdr_type, int components, int samples,
char err_out[256])
{
GLenum type, format, internalformat;
void *pixels = NULL;
if (samples) {
CLAMP_MAX(samples, GPU_max_color_texture_samples());
}
GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
tex->w = w;
tex->h = h;
tex->number = -1;
tex->refcount = 1;
tex->target = (n == 1) ? GL_TEXTURE_1D : (samples ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D);
tex->target_base = (n == 1) ? GL_TEXTURE_1D : GL_TEXTURE_2D;
tex->depth = depth;
tex->fb_attachment = -1;
glGenTextures(1, &tex->bindcode);
if (!tex->bindcode) {
if (err_out) {
BLI_snprintf(err_out, 256, "GPUTexture: texture create failed: %d",
(int)glGetError());
}
else {
fprintf(stderr, "GPUTexture: texture create failed: %d\n",
(int)glGetError());
}
GPU_texture_free(tex);
return NULL;
}
if (!GPU_full_non_power_of_two_support()) {
tex->w = power_of_2_max_i(tex->w);
tex->h = power_of_2_max_i(tex->h);
}
tex->number = 0;
glBindTexture(tex->target, tex->bindcode);
if (depth) {
type = GL_UNSIGNED_BYTE;
format = GL_DEPTH_COMPONENT;
internalformat = GL_DEPTH_COMPONENT;
}
else {
type = GL_FLOAT;
if (components == 4) {
format = GL_RGBA;
switch (hdr_type) {
case GPU_HDR_NONE:
internalformat = GL_RGBA8;
break;
/* the following formats rely on ARB_texture_float or OpenGL 3.0 */
case GPU_HDR_HALF_FLOAT:
internalformat = GL_RGBA16F_ARB;
break;
case GPU_HDR_FULL_FLOAT:
internalformat = GL_RGBA32F_ARB;
break;
default:
break;
}
}
else if (components == 2) {
/* these formats rely on ARB_texture_rg or OpenGL 3.0 */
format = GL_RG;
switch (hdr_type) {
case GPU_HDR_NONE:
internalformat = GL_RG8;
break;
case GPU_HDR_HALF_FLOAT:
internalformat = GL_RG16F;
break;
case GPU_HDR_FULL_FLOAT:
internalformat = GL_RG32F;
break;
default:
break;
}
}
if (fpixels && hdr_type == GPU_HDR_NONE) {
type = GL_UNSIGNED_BYTE;
pixels = GPU_texture_convert_pixels(w * h, fpixels);
}
}
if (tex->target == GL_TEXTURE_1D) {
glTexImage1D(tex->target, 0, internalformat, tex->w, 0, format, type, NULL);
if (fpixels) {
glTexSubImage1D(tex->target, 0, 0, w, format, type,
pixels ? pixels : fpixels);
if (tex->w > w) {
GPU_glTexSubImageEmpty(tex->target, format, w, 0, tex->w - w, 1);
}
}
}
else {
if (samples) {
glTexImage2DMultisample(tex->target, samples, internalformat, tex->w, tex->h, true);
}
else {
glTexImage2D(tex->target, 0, internalformat, tex->w, tex->h, 0,
format, type, NULL);
}
if (fpixels) {
glTexSubImage2D(tex->target, 0, 0, 0, w, h,
format, type, pixels ? pixels : fpixels);
if (tex->w > w)
GPU_glTexSubImageEmpty(tex->target, format, w, 0, tex->w - w, tex->h);
if (tex->h > h)
GPU_glTexSubImageEmpty(tex->target, format, 0, h, w, tex->h - h);
}
}
if (pixels)
MEM_freeN(pixels);
if (depth) {
glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(tex->target_base, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(tex->target_base, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY);
}
else {
glTexParameteri(tex->target_base, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(tex->target_base, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
if (tex->target_base != GL_TEXTURE_1D) {
glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
else
glTexParameteri(tex->target_base, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
return tex;
}
void draw_smoke_volume(SmokeDomainSettings *sds, Object *ob,
GPUTexture *tex, float min[3], float max[3],
int res[3], float dx, float UNUSED(base_scale), float viewnormal[3],
GPUTexture *tex_shadow, GPUTexture *tex_flame)
{
int i, j, k, n, good_index;
float d /*, d0 */ /* UNUSED */, dd, ds;
float *points = NULL;
int numpoints = 0;
float cor[3] = {1.0f, 1.0f, 1.0f};
int gl_depth = 0, gl_blend = 0;
/* draw slices of smoke is adapted from c++ code authored
* by: Johannes Schmid and Ingemar Rask, 2006, [email protected] */
float cv[][3] = {
{1.0f, 1.0f, 1.0f}, {-1.0f, 1.0f, 1.0f}, {-1.0f, -1.0f, 1.0f}, {1.0f, -1.0f, 1.0f},
{1.0f, 1.0f, -1.0f}, {-1.0f, 1.0f, -1.0f}, {-1.0f, -1.0f, -1.0f}, {1.0f, -1.0f, -1.0f}
};
/* edges have the form edges[n][0][xyz] + t*edges[n][1][xyz] */
float edges[12][2][3] = {
{{1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{-1.0f, 1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{-1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{1.0f, -1.0f, -1.0f}, {0.0f, 0.0f, 2.0f}},
{{1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, -1.0f, 1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
{{1.0f, -1.0f, -1.0f}, {0.0f, 2.0f, 0.0f}},
{{-1.0f, 1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, -1.0f, 1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, -1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}},
{{-1.0f, 1.0f, -1.0f}, {2.0f, 0.0f, 0.0f}}
};
unsigned char *spec_data;
float *spec_pixels;
GPUTexture *tex_spec;
/* Fragment program to calculate the view3d of smoke */
/* using 4 textures, density, shadow, flame and flame spectrum */
const char *shader_basic =
"!!ARBfp1.0\n"
"PARAM dx = program.local[0];\n"
"PARAM darkness = program.local[1];\n"
"PARAM render = program.local[2];\n"
"PARAM f = {1.442695041, 1.442695041, 1.442695041, 0.01};\n"
"TEMP temp, shadow, flame, spec, value;\n"
"TEX temp, fragment.texcoord[0], texture[0], 3D;\n"
"TEX shadow, fragment.texcoord[0], texture[1], 3D;\n"
"TEX flame, fragment.texcoord[0], texture[2], 3D;\n"
"TEX spec, flame.r, texture[3], 1D;\n"
/* calculate shading factor from density */
"MUL value.r, temp.a, darkness.a;\n"
"MUL value.r, value.r, dx.r;\n"
"MUL value.r, value.r, f.r;\n"
"EX2 temp, -value.r;\n"
/* alpha */
"SUB temp.a, 1.0, temp.r;\n"
/* shade colors */
"MUL temp.r, temp.r, shadow.r;\n"
"MUL temp.g, temp.g, shadow.r;\n"
"MUL temp.b, temp.b, shadow.r;\n"
"MUL temp.r, temp.r, darkness.r;\n"
"MUL temp.g, temp.g, darkness.g;\n"
"MUL temp.b, temp.b, darkness.b;\n"
/* for now this just replace smoke shading if rendering fire */
"CMP result.color, render.r, temp, spec;\n"
"END\n";
/* color shader */
const char *shader_color =
"!!ARBfp1.0\n"
"PARAM dx = program.local[0];\n"
"PARAM darkness = program.local[1];\n"
"PARAM render = program.local[2];\n"
"PARAM f = {1.442695041, 1.442695041, 1.442695041, 1.442695041};\n"
"TEMP temp, shadow, flame, spec, value;\n"
"TEX temp, fragment.texcoord[0], texture[0], 3D;\n"
"TEX shadow, fragment.texcoord[0], texture[1], 3D;\n"
"TEX flame, fragment.texcoord[0], texture[2], 3D;\n"
"TEX spec, flame.r, texture[3], 1D;\n"
/* unpremultiply volume texture */
"RCP value.r, temp.a;\n"
"MUL temp.r, temp.r, value.r;\n"
"MUL temp.g, temp.g, value.r;\n"
"MUL temp.b, temp.b, value.r;\n"
/* calculate shading factor from density */
"MUL value.r, temp.a, darkness.a;\n"
"MUL value.r, value.r, dx.r;\n"
"MUL value.r, value.r, f.r;\n"
"EX2 value.r, -value.r;\n"
/* alpha */
"SUB temp.a, 1.0, value.r;\n"
/* shade colors */
"MUL temp.r, temp.r, shadow.r;\n"
"MUL temp.g, temp.g, shadow.r;\n"
"MUL temp.b, temp.b, shadow.r;\n"
"MUL temp.r, temp.r, value.r;\n"
"MUL temp.g, temp.g, value.r;\n"
"MUL temp.b, temp.b, value.r;\n"
/* for now this just replace smoke shading if rendering fire */
"CMP result.color, render.r, temp, spec;\n"
"END\n";
GLuint prog;
float size[3];
if (!tex) {
printf("Could not allocate 3D texture for 3D View smoke drawing.\n");
return;
}
#ifdef DEBUG_DRAW_TIME
TIMEIT_START(draw);
#endif
/* generate flame spectrum texture */
#define SPEC_WIDTH 256
#define FIRE_THRESH 7
#define MAX_FIRE_ALPHA 0.06f
#define FULL_ON_FIRE 100
spec_data = malloc(SPEC_WIDTH * 4 * sizeof(unsigned char));
flame_get_spectrum(spec_data, SPEC_WIDTH, 1500, 3000);
spec_pixels = malloc(SPEC_WIDTH * 4 * 16 * 16 * sizeof(float));
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
for (k = 0; k < SPEC_WIDTH; k++) {
int index = (j * SPEC_WIDTH * 16 + i * SPEC_WIDTH + k) * 4;
if (k >= FIRE_THRESH) {
spec_pixels[index] = ((float)spec_data[k * 4]) / 255.0f;
spec_pixels[index + 1] = ((float)spec_data[k * 4 + 1]) / 255.0f;
spec_pixels[index + 2] = ((float)spec_data[k * 4 + 2]) / 255.0f;
spec_pixels[index + 3] = MAX_FIRE_ALPHA * (
(k > FULL_ON_FIRE) ? 1.0f : (k - FIRE_THRESH) / ((float)FULL_ON_FIRE - FIRE_THRESH));
}
else {
spec_pixels[index] = spec_pixels[index + 1] = spec_pixels[index + 2] = spec_pixels[index + 3] = 0.0f;
}
}
}
}
tex_spec = GPU_texture_create_1D(SPEC_WIDTH, spec_pixels, NULL);
sub_v3_v3v3(size, max, min);
/* maxx, maxy, maxz */
cv[0][0] = max[0];
cv[0][1] = max[1];
cv[0][2] = max[2];
/* minx, maxy, maxz */
cv[1][0] = min[0];
cv[1][1] = max[1];
cv[1][2] = max[2];
/* minx, miny, maxz */
cv[2][0] = min[0];
cv[2][1] = min[1];
cv[2][2] = max[2];
/* maxx, miny, maxz */
cv[3][0] = max[0];
cv[3][1] = min[1];
cv[3][2] = max[2];
/* maxx, maxy, minz */
cv[4][0] = max[0];
cv[4][1] = max[1];
cv[4][2] = min[2];
/* minx, maxy, minz */
cv[5][0] = min[0];
cv[5][1] = max[1];
cv[5][2] = min[2];
/* minx, miny, minz */
cv[6][0] = min[0];
cv[6][1] = min[1];
cv[6][2] = min[2];
/* maxx, miny, minz */
cv[7][0] = max[0];
cv[7][1] = min[1];
cv[7][2] = min[2];
copy_v3_v3(edges[0][0], cv[4]); /* maxx, maxy, minz */
copy_v3_v3(edges[1][0], cv[5]); /* minx, maxy, minz */
copy_v3_v3(edges[2][0], cv[6]); /* minx, miny, minz */
copy_v3_v3(edges[3][0], cv[7]); /* maxx, miny, minz */
copy_v3_v3(edges[4][0], cv[3]); /* maxx, miny, maxz */
copy_v3_v3(edges[5][0], cv[2]); /* minx, miny, maxz */
copy_v3_v3(edges[6][0], cv[6]); /* minx, miny, minz */
copy_v3_v3(edges[7][0], cv[7]); /* maxx, miny, minz */
copy_v3_v3(edges[8][0], cv[1]); /* minx, maxy, maxz */
copy_v3_v3(edges[9][0], cv[2]); /* minx, miny, maxz */
copy_v3_v3(edges[10][0], cv[6]); /* minx, miny, minz */
copy_v3_v3(edges[11][0], cv[5]); /* minx, maxy, minz */
// printf("size x: %f, y: %f, z: %f\n", size[0], size[1], size[2]);
// printf("min[2]: %f, max[2]: %f\n", min[2], max[2]);
edges[0][1][2] = size[2];
edges[1][1][2] = size[2];
edges[2][1][2] = size[2];
edges[3][1][2] = size[2];
edges[4][1][1] = size[1];
edges[5][1][1] = size[1];
edges[6][1][1] = size[1];
edges[7][1][1] = size[1];
edges[8][1][0] = size[0];
edges[9][1][0] = size[0];
edges[10][1][0] = size[0];
edges[11][1][0] = size[0];
glGetBooleanv(GL_BLEND, (GLboolean *)&gl_blend);
glGetBooleanv(GL_DEPTH_TEST, (GLboolean *)&gl_depth);
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
/* find cube vertex that is closest to the viewer */
for (i = 0; i < 8; i++) {
float x, y, z;
x = cv[i][0] - viewnormal[0] * size[0] * 0.5f;
y = cv[i][1] - viewnormal[1] * size[1] * 0.5f;
z = cv[i][2] - viewnormal[2] * size[2] * 0.5f;
if ((x >= min[0]) && (x <= max[0]) &&
(y >= min[1]) && (y <= max[1]) &&
(z >= min[2]) && (z <= max[2]))
{
break;
}
}
if (i >= 8) {
/* fallback, avoid using buffer over-run */
i = 0;
}
// printf("i: %d\n", i);
// printf("point %f, %f, %f\n", cv[i][0], cv[i][1], cv[i][2]);
if (GL_TRUE == glewIsSupported("GL_ARB_fragment_program")) {
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glGenProgramsARB(1, &prog);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
/* set shader */
if (sds->active_fields & SM_ACTIVE_COLORS)
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(shader_color), shader_color);
else
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(shader_basic), shader_basic);
/* cell spacing */
glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, dx, dx, dx, 1.0);
/* custom parameter for smoke style (higher = thicker) */
if (sds->active_fields & SM_ACTIVE_COLORS)
glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, 1.0, 1.0, 1.0, 10.0);
else
glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 1, sds->active_color[0], sds->active_color[1], sds->active_color[2], 10.0);
}
else
printf("Your gfx card does not support 3D View smoke drawing.\n");
GPU_texture_bind(tex, 0);
if (tex_shadow)
GPU_texture_bind(tex_shadow, 1);
else
printf("No volume shadow\n");
if (tex_flame) {
GPU_texture_bind(tex_flame, 2);
GPU_texture_bind(tex_spec, 3);
}
if (!GPU_non_power_of_two_support()) {
cor[0] = (float)res[0] / (float)power_of_2_max_i(res[0]);
cor[1] = (float)res[1] / (float)power_of_2_max_i(res[1]);
cor[2] = (float)res[2] / (float)power_of_2_max_i(res[2]);
}
/* our slices are defined by the plane equation a*x + b*y +c*z + d = 0
* (a,b,c), the plane normal, are given by viewdir
* d is the parameter along the view direction. the first d is given by
* inserting previously found vertex into the plane equation */
/* d0 = (viewnormal[0]*cv[i][0] + viewnormal[1]*cv[i][1] + viewnormal[2]*cv[i][2]); */ /* UNUSED */
ds = (fabsf(viewnormal[0]) * size[0] + fabsf(viewnormal[1]) * size[1] + fabsf(viewnormal[2]) * size[2]);
dd = max_fff(sds->global_size[0], sds->global_size[1], sds->global_size[2]) / 128.f;
n = 0;
good_index = i;
// printf("d0: %f, dd: %f, ds: %f\n\n", d0, dd, ds);
points = MEM_callocN(sizeof(float) * 12 * 3, "smoke_points_preview");
while (1) {
float p0[3];
float tmp_point[3], tmp_point2[3];
if (dd * (float)n > ds)
break;
copy_v3_v3(tmp_point, viewnormal);
mul_v3_fl(tmp_point, -dd * ((ds / dd) - (float)n));
add_v3_v3v3(tmp_point2, cv[good_index], tmp_point);
d = dot_v3v3(tmp_point2, viewnormal);
// printf("my d: %f\n", d);
/* intersect_edges returns the intersection points of all cube edges with
* the given plane that lie within the cube */
numpoints = intersect_edges(points, viewnormal[0], viewnormal[1], viewnormal[2], -d, edges);
// printf("points: %d\n", numpoints);
if (numpoints > 2) {
copy_v3_v3(p0, points);
/* sort points to get a convex polygon */
for (i = 1; i < numpoints - 1; i++) {
for (j = i + 1; j < numpoints; j++) {
if (!convex(p0, viewnormal, &points[j * 3], &points[i * 3])) {
float tmp2[3];
copy_v3_v3(tmp2, &points[j * 3]);
copy_v3_v3(&points[j * 3], &points[i * 3]);
copy_v3_v3(&points[i * 3], tmp2);
}
}
}
/* render fire slice */
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, 1.0, 0.0, 0.0, 0.0);
glBegin(GL_POLYGON);
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < numpoints; i++) {
glTexCoord3d((points[i * 3 + 0] - min[0]) * cor[0] / size[0],
(points[i * 3 + 1] - min[1]) * cor[1] / size[1],
(points[i * 3 + 2] - min[2]) * cor[2] / size[2]);
glVertex3f(points[i * 3 + 0] / fabsf(ob->size[0]),
points[i * 3 + 1] / fabsf(ob->size[1]),
points[i * 3 + 2] / fabsf(ob->size[2]));
}
glEnd();
/* render smoke slice */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 2, -1.0, 0.0, 0.0, 0.0);
glBegin(GL_POLYGON);
glColor3f(1.0, 1.0, 1.0);
for (i = 0; i < numpoints; i++) {
glTexCoord3d((points[i * 3 + 0] - min[0]) * cor[0] / size[0],
(points[i * 3 + 1] - min[1]) * cor[1] / size[1],
(points[i * 3 + 2] - min[2]) * cor[2] / size[2]);
glVertex3f(points[i * 3 + 0] / fabsf(ob->size[0]),
points[i * 3 + 1] / fabsf(ob->size[1]),
points[i * 3 + 2] / fabsf(ob->size[2]));
}
glEnd();
}
n++;
}
#ifdef DEBUG_DRAW_TIME
printf("Draw Time: %f\n", (float)TIMEIT_VALUE(draw));
TIMEIT_END(draw);
#endif
if (tex_shadow)
GPU_texture_unbind(tex_shadow);
GPU_texture_unbind(tex);
if (tex_flame) {
GPU_texture_unbind(tex_flame);
GPU_texture_unbind(tex_spec);
}
GPU_texture_free(tex_spec);
free(spec_data);
free(spec_pixels);
if (GLEW_ARB_fragment_program) {
glDisable(GL_FRAGMENT_PROGRAM_ARB);
glDeleteProgramsARB(1, &prog);
}
MEM_freeN(points);
if (!gl_blend) {
glDisable(GL_BLEND);
}
if (gl_depth) {
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
}
}
void draw_smoke_volume(SmokeDomainSettings *sds, Object *ob,
const float min[3], const float max[3],
const float viewnormal[3])
{
if (!sds->tex || !sds->tex_shadow) {
fprintf(stderr, "Could not allocate 3D texture for volume rendering!\n");
return;
}
const bool use_fire = (sds->active_fields & SM_ACTIVE_FIRE) && sds->tex_flame;
GPUShader *shader = GPU_shader_get_builtin_shader(
(use_fire) ? GPU_SHADER_SMOKE_FIRE : GPU_SHADER_SMOKE);
if (!shader) {
fprintf(stderr, "Unable to create GLSL smoke shader.\n");
return;
}
const float ob_sizei[3] = {
1.0f / fabsf(ob->size[0]),
1.0f / fabsf(ob->size[1]),
1.0f / fabsf(ob->size[2])
};
const float size[3] = { max[0] - min[0], max[1] - min[1], max[2] - min[2] };
const float invsize[3] = { 1.0f / size[0], 1.0f / size[1], 1.0f / size[2] };
#ifdef DEBUG_DRAW_TIME
TIMEIT_START(draw);
#endif
/* setup smoke shader */
int soot_location = GPU_shader_get_uniform(shader, "soot_texture");
int spec_location = GPU_shader_get_uniform(shader, "spectrum_texture");
int shadow_location = GPU_shader_get_uniform(shader, "shadow_texture");
int flame_location = GPU_shader_get_uniform(shader, "flame_texture");
int actcol_location = GPU_shader_get_uniform(shader, "active_color");
int stepsize_location = GPU_shader_get_uniform(shader, "step_size");
int densityscale_location = GPU_shader_get_uniform(shader, "density_scale");
int invsize_location = GPU_shader_get_uniform(shader, "invsize");
int ob_sizei_location = GPU_shader_get_uniform(shader, "ob_sizei");
int min_location = GPU_shader_get_uniform(shader, "min");
GPU_shader_bind(shader);
GPU_texture_bind(sds->tex, 0);
GPU_shader_uniform_texture(shader, soot_location, sds->tex);
GPU_texture_bind(sds->tex_shadow, 1);
GPU_shader_uniform_texture(shader, shadow_location, sds->tex_shadow);
GPUTexture *tex_spec = NULL;
if (use_fire) {
GPU_texture_bind(sds->tex_flame, 2);
GPU_shader_uniform_texture(shader, flame_location, sds->tex_flame);
tex_spec = create_flame_spectrum_texture();
GPU_texture_bind(tex_spec, 3);
GPU_shader_uniform_texture(shader, spec_location, tex_spec);
}
float active_color[3] = { 0.9, 0.9, 0.9 };
float density_scale = 10.0f;
if ((sds->active_fields & SM_ACTIVE_COLORS) == 0)
mul_v3_v3(active_color, sds->active_color);
GPU_shader_uniform_vector(shader, actcol_location, 3, 1, active_color);
GPU_shader_uniform_vector(shader, stepsize_location, 1, 1, &sds->dx);
GPU_shader_uniform_vector(shader, densityscale_location, 1, 1, &density_scale);
GPU_shader_uniform_vector(shader, min_location, 3, 1, min);
GPU_shader_uniform_vector(shader, ob_sizei_location, 3, 1, ob_sizei);
GPU_shader_uniform_vector(shader, invsize_location, 3, 1, invsize);
/* setup slicing information */
const int max_slices = 256;
const int max_points = max_slices * 12;
VolumeSlicer slicer;
copy_v3_v3(slicer.min, min);
copy_v3_v3(slicer.max, max);
copy_v3_v3(slicer.size, size);
slicer.verts = MEM_mallocN(sizeof(float) * 3 * max_points, "smoke_slice_vertices");
const int num_points = create_view_aligned_slices(&slicer, max_slices, viewnormal);
/* setup buffer and draw */
int gl_depth = 0, gl_blend = 0;
glGetBooleanv(GL_BLEND, (GLboolean *)&gl_blend);
glGetBooleanv(GL_DEPTH_TEST, (GLboolean *)&gl_depth);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
GLuint vertex_buffer;
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * num_points, &slicer.verts[0][0], GL_STATIC_DRAW);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, NULL);
glDrawArrays(GL_TRIANGLES, 0, num_points);
glDisableClientState(GL_VERTEX_ARRAY);
#ifdef DEBUG_DRAW_TIME
printf("Draw Time: %f\n", (float)TIMEIT_VALUE(draw));
TIMEIT_END(draw);
#endif
/* cleanup */
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &vertex_buffer);
GPU_texture_unbind(sds->tex);
GPU_texture_unbind(sds->tex_shadow);
if (use_fire) {
GPU_texture_unbind(sds->tex_flame);
GPU_texture_unbind(tex_spec);
GPU_texture_free(tex_spec);
}
MEM_freeN(slicer.verts);
GPU_shader_unbind();
if (!gl_blend) {
glDisable(GL_BLEND);
}
if (gl_depth) {
glEnable(GL_DEPTH_TEST);
}
}
GPUTexture *GPU_texture_create_3D(int w, int h, int depth, int channels, const float *fpixels)
{
GLenum type, format, internalformat;
void *pixels = NULL;
GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
tex->w = w;
tex->h = h;
tex->depth = depth;
tex->number = -1;
tex->refcount = 1;
tex->target = GL_TEXTURE_3D;
tex->target_base = GL_TEXTURE_3D;
glGenTextures(1, &tex->bindcode);
if (!tex->bindcode) {
fprintf(stderr, "GPUTexture: texture create failed: %d\n",
(int)glGetError());
GPU_texture_free(tex);
return NULL;
}
tex->number = 0;
glBindTexture(tex->target, tex->bindcode);
GPU_ASSERT_NO_GL_ERRORS("3D glBindTexture");
type = GL_FLOAT;
if (channels == 4) {
format = GL_RGBA;
internalformat = GL_RGBA8;
}
else {
format = GL_RED;
internalformat = GL_INTENSITY8;
}
/* 3D textures are quite heavy, test if it's possible to create them first */
glTexImage3D(GL_PROXY_TEXTURE_3D, 0, internalformat, tex->w, tex->h, tex->depth, 0, format, type, NULL);
bool rescale = false;
int r_width;
glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_WIDTH, &r_width);
while (r_width == 0) {
rescale = true;
tex->w /= 2;
tex->h /= 2;
tex->depth /= 2;
glTexImage3D(GL_PROXY_TEXTURE_3D, 0, internalformat, tex->w, tex->h, tex->depth, 0, format, type, NULL);
glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_WIDTH, &r_width);
}
/* really unlikely to happen but keep this just in case */
tex->w = max_ii(tex->w, 1);
tex->h = max_ii(tex->h, 1);
tex->depth = max_ii(tex->depth, 1);
#if 0
if (fpixels)
pixels = GPU_texture_convert_pixels(w*h*depth, fpixels);
#endif
GPU_ASSERT_NO_GL_ERRORS("3D glTexImage3D");
/* hardcore stuff, 3D texture rescaling - warning, this is gonna hurt your performance a lot, but we need it
* for gooseberry */
if (rescale && fpixels) {
/* FIXME: should these be floating point? */
const unsigned int xf = w / tex->w, yf = h / tex->h, zf = depth / tex->depth;
float *tex3d = MEM_mallocN(channels * sizeof(float) * tex->w * tex->h * tex->depth, "tex3d");
GPU_print_error_debug("You need to scale a 3D texture, feel the pain!");
for (unsigned k = 0; k < tex->depth; k++) {
for (unsigned j = 0; j < tex->h; j++) {
for (unsigned i = 0; i < tex->w; i++) {
/* obviously doing nearest filtering here,
* it's going to be slow in any case, let's not make it worse */
float xb = i * xf;
float yb = j * yf;
float zb = k * zf;
unsigned int offset = k * (tex->w * tex->h) + i * tex->h + j;
unsigned int offset_orig = (zb) * (w * h) + (xb) * h + (yb);
if (channels == 4) {
tex3d[offset * 4] = fpixels[offset_orig * 4];
tex3d[offset * 4 + 1] = fpixels[offset_orig * 4 + 1];
tex3d[offset * 4 + 2] = fpixels[offset_orig * 4 + 2];
tex3d[offset * 4 + 3] = fpixels[offset_orig * 4 + 3];
}
else
tex3d[offset] = fpixels[offset_orig];
}
}
}
glTexImage3D(tex->target, 0, internalformat, tex->w, tex->h, tex->depth, 0, format, type, tex3d);
MEM_freeN(tex3d);
}
else {
if (fpixels) {
glTexImage3D(tex->target, 0, internalformat, tex->w, tex->h, tex->depth, 0, format, type, fpixels);
GPU_ASSERT_NO_GL_ERRORS("3D glTexSubImage3D");
}
}
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
if (pixels)
MEM_freeN(pixels);
GPU_texture_unbind(tex);
return tex;
}