120 lines
3.7 KiB
C++
120 lines
3.7 KiB
C++
/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0 */
|
|
|
|
/* Volume Primitive
|
|
*
|
|
* Volumes are just regions inside meshes with the mesh surface as boundaries.
|
|
* There isn't as much data to access as for surfaces, there is only a position
|
|
* to do lookups in 3D voxel or procedural textures.
|
|
*
|
|
* 3D voxel textures can be assigned as attributes per mesh, which means the
|
|
* same shader can be used for volume objects with different densities, etc. */
|
|
|
|
#pragma once
|
|
|
|
#include "kernel/globals.h"
|
|
|
|
#include "kernel/geom/attribute.h"
|
|
#include "kernel/geom/object.h"
|
|
|
|
#include "kernel/util/image_3d.h"
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
#ifdef __VOLUME__
|
|
|
|
/* Return position normalized to 0..1 in mesh bounds */
|
|
|
|
template<typename Float3Type>
|
|
ccl_device_inline Float3Type volume_normalized_position(KernelGlobals kg,
|
|
const ccl_private ShaderData *sd,
|
|
Float3Type P)
|
|
{
|
|
const AttributeDescriptor desc = find_attribute(kg, sd, ATTR_STD_GENERATED_TRANSFORM);
|
|
|
|
object_inverse_position_transform_if_object(kg, sd, &P);
|
|
|
|
if (is_attribute_found(desc)) {
|
|
const Transform tfm = primitive_attribute_matrix(kg, desc);
|
|
P = transform_point(&tfm, P);
|
|
}
|
|
|
|
return P;
|
|
}
|
|
|
|
template<typename T> ccl_device_inline T volume_attribute_value(const float4 value);
|
|
|
|
ccl_device_template_spec float volume_attribute_value(const float4 value)
|
|
{
|
|
return average(make_float3(value));
|
|
}
|
|
|
|
ccl_device_template_spec float2 volume_attribute_value(const float4 value)
|
|
{
|
|
return make_float2(value.x, value.y);
|
|
}
|
|
|
|
ccl_device_template_spec float3 volume_attribute_value(const float4 value)
|
|
{
|
|
return make_float3(value);
|
|
}
|
|
|
|
ccl_device_template_spec float4 volume_attribute_value(const float4 value)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
ccl_device float volume_attribute_alpha(const float4 value)
|
|
{
|
|
return value.w;
|
|
}
|
|
|
|
ccl_device float4 volume_attribute_float4(KernelGlobals kg,
|
|
ccl_private ShaderData *sd,
|
|
const AttributeDescriptor desc,
|
|
const bool stochastic)
|
|
{
|
|
if (desc.element & (ATTR_ELEMENT_OBJECT | ATTR_ELEMENT_MESH)) {
|
|
switch (desc.type) {
|
|
case NODE_ATTR_FLOAT: {
|
|
const float f = kernel_data_fetch(attributes_float, desc.offset);
|
|
return make_float4(f, f, f, 1.0f);
|
|
}
|
|
case NODE_ATTR_FLOAT2: {
|
|
const float2 f = kernel_data_fetch(attributes_float2, desc.offset);
|
|
return make_float4(f.x, f.y, 0.0f, 1.0f);
|
|
}
|
|
case NODE_ATTR_FLOAT3: {
|
|
const float3 f = kernel_data_fetch(attributes_float3, desc.offset);
|
|
return make_float4(f.x, f.y, f.z, 1.0f);
|
|
}
|
|
case NODE_ATTR_FLOAT4:
|
|
case NODE_ATTR_RGBA:
|
|
return kernel_data_fetch(attributes_float4, desc.offset);
|
|
case NODE_ATTR_MATRIX:
|
|
return zero_float4();
|
|
}
|
|
}
|
|
if (desc.element & ATTR_ELEMENT_VOXEL) {
|
|
/* todo: optimize this so we don't have to transform both here and in
|
|
* kernel_image_interp_3d when possible. Also could optimize for the
|
|
* common case where transform is translation/scale only. */
|
|
float3 P = sd->P;
|
|
object_inverse_position_transform(kg, sd, &P);
|
|
const InterpolationType interp = (sd->flag & SD_VOLUME_CUBIC) ? INTERPOLATION_CUBIC :
|
|
INTERPOLATION_NONE;
|
|
const float4 value = kernel_image_interp_3d(kg, sd, desc.offset, P, interp, stochastic);
|
|
if (value.w > 1e-6f && value.w != 1.0f) {
|
|
/* For RGBA colors, unpremultiply after interpolation. */
|
|
return make_float4(make_float3(value) / value.w, value.w);
|
|
}
|
|
return value;
|
|
}
|
|
return zero_float4();
|
|
}
|
|
|
|
#endif
|
|
|
|
CCL_NAMESPACE_END
|