void CascadedShadowLayer::UpdateCropMats()
{
for (size_t i = 0; i < intervals_.size(); ++ i)
{
float3 const scale = scales_[i];
float3 const bias = biases_[i];
crop_mats_[i] = MathLib::scaling(scale)
* MathLib::translation(+(2.0f * bias.x() + scale.x() - 1.0f),
-(2.0f * bias.y() + scale.y() - 1.0f), bias.z());
}
}
void OCTree::DivideNode(size_t index, uint32_t curr_depth)
{
if (octree_[index].obj_ptrs.size() > 1)
{
size_t const this_size = octree_.size();
AABBox const parent_bb = octree_[index].bb;
float3 const parent_center = parent_bb.Center();
octree_[index].first_child_index = static_cast<int>(this_size);
octree_[index].visible = BO_No;
octree_.resize(this_size + 8);
for (SceneObjsType::const_reference so : octree_[index].obj_ptrs)
{
AABBox const & aabb = *so->PosBoundWS();
int mark[6];
mark[0] = aabb.Min().x() >= parent_center.x() ? 1 : 0;
mark[1] = aabb.Min().y() >= parent_center.y() ? 2 : 0;
mark[2] = aabb.Min().z() >= parent_center.z() ? 4 : 0;
mark[3] = aabb.Max().x() >= parent_center.x() ? 1 : 0;
mark[4] = aabb.Max().y() >= parent_center.y() ? 2 : 0;
mark[5] = aabb.Max().z() >= parent_center.z() ? 4 : 0;
for (int j = 0; j < 8; ++ j)
{
if (j == ((j & 1) ? mark[3] : mark[0])
+ ((j & 2) ? mark[4] : mark[1])
+ ((j & 4) ? mark[5] : mark[2]))
{
octree_[this_size + j].obj_ptrs.push_back(so);
}
}
}
for (size_t j = 0; j < 8; ++ j)
{
octree_node_t& new_node = octree_[this_size + j];
new_node.first_child_index = -1;
new_node.bb = AABBox(float3((j & 1) ? parent_center.x() : parent_bb.Min().x(),
(j & 2) ? parent_center.y() : parent_bb.Min().y(),
(j & 4) ? parent_center.z() : parent_bb.Min().z()),
float3((j & 1) ? parent_bb.Max().x() : parent_center.x(),
(j & 2) ? parent_bb.Max().y() : parent_center.y(),
(j & 4) ? parent_bb.Max().z() : parent_center.z()));
if (curr_depth < max_tree_depth_)
{
this->DivideNode(this_size + j, curr_depth + 1);
}
}
SceneObjsType empty;
octree_[index].obj_ptrs.swap(empty);
}
}
BoundOverlap OCTree::BoundVisible(size_t index, AABBox const & aabb) const
{
BOOST_ASSERT(index < octree_.size());
octree_node_t const & node = octree_[index];
if ((node.visible != BO_No) && MathLib::intersect_aabb_aabb(node.bb, aabb))
{
if (BO_Yes == node.visible)
{
return BO_Yes;
}
else
{
BOOST_ASSERT(BO_Partial == node.visible);
if (node.first_child_index != -1)
{
float3 const center = node.bb.Center();
int mark[6];
mark[0] = aabb.Min().x() >= center.x() ? 1 : 0;
mark[1] = aabb.Min().y() >= center.y() ? 2 : 0;
mark[2] = aabb.Min().z() >= center.z() ? 4 : 0;
mark[3] = aabb.Max().x() >= center.x() ? 1 : 0;
mark[4] = aabb.Max().y() >= center.y() ? 2 : 0;
mark[5] = aabb.Max().z() >= center.z() ? 4 : 0;
for (int j = 0; j < 8; ++ j)
{
if (j == ((j & 1) ? mark[3] : mark[0])
+ ((j & 2) ? mark[4] : mark[1])
+ ((j & 4) ? mark[5] : mark[2]))
{
BoundOverlap const bo = this->BoundVisible(node.first_child_index + j, aabb);
if (bo != BO_No)
{
return bo;
}
}
}
return BO_No;
}
else
{
return BO_Partial;
}
}
}
else
{
return BO_No;
}
}
void LightSource::Color(float3 const & clr)
{
color_ = float4(clr.x(), clr.y(), clr.z(),
MathLib::dot(clr, float3(0.2126f, 0.7152f, 0.0722f)));
this->Range(-1);
}
// 设置声源方向
/////////////////////////////////////////////////////////////////////////////////
void DSMusicBuffer::Direction(float3 const & v)
{
if (ds3DBuffer_)
{
ds3DBuffer_->SetConeOrientation(v.x(), v.y(), v.z(), DS3D_IMMEDIATE);
}
}
float find_minimum_quantization_error(float3 normal)
{
normal /= max(abs(normal.x()), max(abs(normal.y()), abs(normal.z())));
float min_error = 1e10f;
float ret = 1;
for (int step = 1; step < 128; ++ step)
{
float t = (step + 0.5f) / 127.5f;
// compute the probe
float3 p = normal * t;
// quantize the probe
float3 quantized_p = float3(quantize255(p.x()), quantize255(p.y()), quantize255(p.z()));
// error computation for the probe
float3 diff = (quantized_p - p) / t;
float error = max(abs(diff.x()), max(abs(diff.y()), abs(diff.z())));
// find the minimum
if (error < min_error)
{
min_error = error;
ret = t;
}
}
return ret;
}
// 设置声源速度
/////////////////////////////////////////////////////////////////////////////////
void DSMusicBuffer::Velocity(float3 const & v)
{
if (ds3DBuffer_)
{
ds3DBuffer_->SetVelocity(v.x(), v.y(), v.z(), DS3D_IMMEDIATE);
}
}
// 设置声源位置
/////////////////////////////////////////////////////////////////////////////////
void DSMusicBuffer::Position(float3 const & v)
{
if (ds3DBuffer_)
{
ds3DBuffer_->SetPosition(v.x(), v.y(), v.z(), DS3D_IMMEDIATE);
}
}
// 3D Multi-octave Simplex noise.
//
// For each octave, a higher frequency/lower amplitude function will be added to the original.
// The higher the persistence [0-1], the more of each succeeding octave will be added.
float simplexNoise( const int octaves, const float persistence, const float scale, const float3 &v ) {
float total = 0;
float frequency = scale;
float amplitude = 1;
// We have to keep track of the largest possible amplitude,
// because each octave adds more, and we need a value in [-1, 1].
float maxAmplitude = 0;
for( int i=0; i < octaves; i++ ) {
total += simplexRawNoise( v.x() * frequency, v.y() * frequency, v.z() * frequency ) * amplitude;
frequency *= 2;
maxAmplitude += amplitude;
amplitude *= persistence;
}
return total / maxAmplitude;
}
// 设置3D听者速度
/////////////////////////////////////////////////////////////////////////////////
void DSAudioEngine::SetListenerVel(float3 const & v)
{
this->ds3dListener_->SetVelocity(v.x(), v.y(), v.z(), DS3D_IMMEDIATE);
}
// 设置3D听者位置
/////////////////////////////////////////////////////////////////////////////////
void DSAudioEngine::SetListenerPos(float3 const & v)
{
this->ds3dListener_->SetPosition(v.x(), v.y(), v.z(), DS3D_IMMEDIATE);
}
void SDSMCascadedShadowLayer::UpdateCascades(Camera const & camera, float4x4 const & light_view_proj,
float3 const & light_space_border)
{
RenderFactory& rf = Context::Instance().RenderFactoryInstance();
RenderEngine& re = rf.RenderEngineInstance();
uint32_t const num_cascades = static_cast<uint32_t>(intervals_.size());
uint32_t const copy_index = frame_index_ & 1;
uint32_t const read_back_index = (0 == frame_index_) ? copy_index : !copy_index;
if (cs_support_)
{
re.BindFrameBuffer(FrameBufferPtr());
float max_blur_light_space = 8.0f / 1024;
float3 max_cascade_scale(max_blur_light_space / light_space_border.x(),
max_blur_light_space / light_space_border.y(),
std::numeric_limits<float>::max());
int const TILE_DIM = 128;
int dispatch_x = (depth_tex_->Width(0) + TILE_DIM - 1) / TILE_DIM;
int dispatch_y = (depth_tex_->Height(0) + TILE_DIM - 1) / TILE_DIM;
*interval_buff_param_ = interval_buff_;
*interval_buff_uint_param_ = interval_buff_;
*interval_buff_read_param_ = interval_buff_;
*cascade_min_buff_uint_param_ = cascade_min_buff_;
*cascade_max_buff_uint_param_ = cascade_max_buff_;
*cascade_min_buff_read_param_ = cascade_min_buff_;
*cascade_max_buff_read_param_ = cascade_max_buff_;
*scale_buff_param_ = scale_buff_;
*bias_buff_param_ = bias_buff_;
*depth_tex_param_ = depth_tex_;
*num_cascades_param_ = static_cast<int32_t>(num_cascades);
*inv_depth_width_height_param_ = float2(1.0f / depth_tex_->Width(0), 1.0f / depth_tex_->Height(0));
*near_far_param_ = float2(camera.NearPlane(), camera.FarPlane());
float4x4 const & inv_proj = camera.InverseProjMatrix();
float3 upper_left = MathLib::transform_coord(float3(-1, +1, 1), inv_proj);
float3 upper_right = MathLib::transform_coord(float3(+1, +1, 1), inv_proj);
float3 lower_left = MathLib::transform_coord(float3(-1, -1, 1), inv_proj);
*upper_left_param_ = upper_left;
*xy_dir_param_ = float2(upper_right.x() - upper_left.x(), lower_left.y() - upper_left.y());
*view_to_light_view_proj_param_ = camera.InverseViewMatrix() * light_view_proj;
*light_space_border_param_ = light_space_border;
*max_cascade_scale_param_ = max_cascade_scale;
re.Dispatch(*clear_z_bounds_tech_, 1, 1, 1);
re.Dispatch(*reduce_z_bounds_from_depth_tech_, dispatch_x, dispatch_y, 1);
re.Dispatch(*compute_log_cascades_from_z_bounds_tech_, 1, 1, 1);
re.Dispatch(*clear_cascade_bounds_tech_, 1, 1, 1);
re.Dispatch(*reduce_bounds_from_depth_tech_, dispatch_x, dispatch_y, 1);
re.Dispatch(*compute_custom_cascades_tech_, 1, 1, 1);
interval_buff_->CopyToBuffer(*interval_cpu_buffs_[copy_index]);
scale_buff_->CopyToBuffer(*scale_cpu_buffs_[copy_index]);
bias_buff_->CopyToBuffer(*bias_cpu_buffs_[copy_index]);
GraphicsBuffer::Mapper interval_mapper(*interval_cpu_buffs_[read_back_index], BA_Read_Only);
GraphicsBuffer::Mapper scale_mapper(*scale_cpu_buffs_[read_back_index], BA_Read_Only);
GraphicsBuffer::Mapper bias_mapper(*bias_cpu_buffs_[read_back_index], BA_Read_Only);
float2* interval_ptr = interval_mapper.Pointer<float2>();
float3* scale_ptr = scale_mapper.Pointer<float3>();
float3* bias_ptr = bias_mapper.Pointer<float3>();
for (size_t i = 0; i < intervals_.size(); ++ i)
{
float3 const & scale = scale_ptr[i];
float3 const & bias = bias_ptr[i];
intervals_[i] = interval_ptr[i];
scales_[i] = scale;
biases_[i] = bias;
}
}
else
{
float2 const near_far(camera.NearPlane(), camera.FarPlane());
reduce_z_bounds_from_depth_pp_->SetParam(1, near_far);
reduce_z_bounds_from_depth_pp_->Apply();
for (uint32_t i = 1; i < depth_deriative_tex_->NumMipMaps(); ++ i)
{
int width = depth_deriative_tex_->Width(i - 1);
int height = depth_deriative_tex_->Height(i - 1);
float delta_x = 1.0f / width;
float delta_y = 1.0f / height;
float4 delta_offset(delta_x, delta_y, -delta_x / 2, -delta_y / 2);
reduce_z_bounds_from_depth_mip_map_pp_->SetParam(0, delta_offset);
reduce_z_bounds_from_depth_mip_map_pp_->OutputPin(0, depth_deriative_small_tex_, i - 1);
reduce_z_bounds_from_depth_mip_map_pp_->Apply();
int sw = depth_deriative_tex_->Width(i);
int sh = depth_deriative_tex_->Height(i);
depth_deriative_small_tex_->CopyToSubTexture2D(*depth_deriative_tex_, 0, i, 0, 0, sw, sh,
0, i - 1, 0, 0, sw, sh);
}
compute_log_cascades_from_z_bounds_pp_->SetParam(1, static_cast<int32_t>(num_cascades));
compute_log_cascades_from_z_bounds_pp_->SetParam(2, near_far);
compute_log_cascades_from_z_bounds_pp_->Apply();
interval_tex_->CopyToSubTexture2D(*interval_cpu_texs_[copy_index], 0, 0, 0, 0, num_cascades, 1,
0, 0, 0, 0, num_cascades, 1);
Texture::Mapper interval_mapper(*interval_cpu_texs_[read_back_index], 0, 0,
TMA_Read_Only, 0, 0, num_cascades, 1);
Vector_T<half, 2>* interval_ptr = interval_mapper.Pointer<Vector_T<half, 2> >();
for (size_t i = 0; i < intervals_.size(); ++ i)
{
float2 const interval(static_cast<float>(interval_ptr[i].x()),
static_cast<float>(interval_ptr[i].y()));
AABBox aabb = CalcFrustumExtents(camera, interval.x(), interval.y(), light_view_proj);
aabb &= AABBox(float3(-1, -1, -1), float3(+1, +1, +1));
aabb.Min() -= light_space_border;
aabb.Max() += light_space_border;
aabb.Min().x() = +aabb.Min().x() * 0.5f + 0.5f;
aabb.Min().y() = -aabb.Min().y() * 0.5f + 0.5f;
aabb.Max().x() = +aabb.Max().x() * 0.5f + 0.5f;
aabb.Max().y() = -aabb.Max().y() * 0.5f + 0.5f;
std::swap(aabb.Min().y(), aabb.Max().y());
float3 const scale = float3(1.0f, 1.0f, 1.0f) / (aabb.Max() - aabb.Min());
float3 const bias = -aabb.Min() * scale;
intervals_[i] = interval;
scales_[i] = scale;
biases_[i] = bias;
}
}
this->UpdateCropMats();
++ frame_index_;
}
void DetailedSkinnedModel::DoBuildModelInfo()
{
bool has_tc = false;
bool has_normal = false;
bool has_tangent_quat = false;
bool has_skinned = false;
RenderLayout const & rl = subrenderables_[0]->GetRenderLayout();
for (uint32_t i = 0; i < rl.NumVertexStreams(); ++ i)
{
switch (rl.VertexStreamFormat(i)[0].usage)
{
case VEU_TextureCoord:
has_tc = true;
break;
case VEU_Normal:
has_normal = true;
break;
case VEU_Tangent:
has_tangent_quat = true;
break;
case VEU_BlendIndex:
case VEU_BlendWeight:
has_skinned = true;
break;
default:
break;
}
}
uint32_t total_num_vertices = 0;
uint32_t total_num_indices = 0;
for (auto const & renderable : subrenderables_)
{
StaticMeshPtr mesh = checked_pointer_cast<StaticMesh>(renderable);
total_num_vertices += mesh->NumVertices();
total_num_indices += mesh->NumTriangles() * 3;
}
RenderFactory& rf = Context::Instance().RenderFactoryInstance();
AABBox const & pos_bb = this->PosBound();
AABBox const & tc_bb = this->TexcoordBound();
float3 const pos_center = pos_bb.Center();
float3 const pos_extent = pos_bb.HalfSize();
float3 const tc_center = tc_bb.Center();
float3 const tc_extent = tc_bb.HalfSize();
std::vector<float3> positions(total_num_vertices);
std::vector<float2> texcoords(total_num_vertices);
std::vector<float3> normals(total_num_vertices);
std::vector<Quaternion> tangent_quats(total_num_vertices);
for (uint32_t i = 0; i < rl.NumVertexStreams(); ++ i)
{
GraphicsBufferPtr const & vb = rl.GetVertexStream(i);
switch (rl.VertexStreamFormat(i)[0].usage)
{
case VEU_Position:
{
GraphicsBufferPtr vb_cpu = rf.MakeVertexBuffer(BU_Static, EAH_CPU_Read, vb->Size(), nullptr);
vb->CopyToBuffer(*vb_cpu);
GraphicsBuffer::Mapper mapper(*vb_cpu, BA_Read_Only);
int16_t const * p_16 = mapper.Pointer<int16_t>();
for (uint32_t j = 0; j < total_num_vertices; ++ j)
{
positions[j].x() = ((p_16[j * 4 + 0] + 32768) / 65535.0f * 2 - 1) * pos_extent.x() + pos_center.x();
positions[j].y() = ((p_16[j * 4 + 1] + 32768) / 65535.0f * 2 - 1) * pos_extent.y() + pos_center.y();
positions[j].z() = ((p_16[j * 4 + 2] + 32768) / 65535.0f * 2 - 1) * pos_extent.z() + pos_center.z();
}
}
break;
case VEU_TextureCoord:
{
GraphicsBufferPtr vb_cpu = rf.MakeVertexBuffer(BU_Static, EAH_CPU_Read, vb->Size(), nullptr);
vb->CopyToBuffer(*vb_cpu);
GraphicsBuffer::Mapper mapper(*vb_cpu, BA_Read_Only);
int16_t const * t_16 = mapper.Pointer<int16_t>();
for (uint32_t j = 0; j < total_num_vertices; ++ j)
{
texcoords[j].x() = ((t_16[j * 2 + 0] + 32768) / 65535.0f * 2 - 1) * tc_extent.x() + tc_center.x();
texcoords[j].y() = ((t_16[j * 2 + 1] + 32768) / 65535.0f * 2 - 1) * tc_extent.y() + tc_center.y();
}
}
break;
case VEU_Normal:
{
GraphicsBufferPtr vb_cpu = rf.MakeVertexBuffer(BU_Static, EAH_CPU_Read, vb->Size(), nullptr);
vb->CopyToBuffer(*vb_cpu);
GraphicsBuffer::Mapper mapper(*vb_cpu, BA_Read_Only);
uint32_t const * n_32 = mapper.Pointer<uint32_t>();
if (EF_A2BGR10 == rl.VertexStreamFormat(i)[0].format)
{
for (uint32_t j = 0; j < total_num_vertices; ++ j)
{
normals[j].x() = ((n_32[j] >> 0) & 0x3FF) / 1023.0f * 2 - 1;
normals[j].y() = ((n_32[j] >> 10) & 0x3FF) / 1023.0f * 2 - 1;
normals[j].z() = ((n_32[j] >> 20) & 0x3FF) / 1023.0f * 2 - 1;
}
}
else if (EF_ABGR8 == rl.VertexStreamFormat(i)[0].format)
{
for (uint32_t j = 0; j < total_num_vertices; ++ j)
{
normals[j].x() = ((n_32[j] >> 0) & 0xFF) / 255.0f * 2 - 1;
normals[j].y() = ((n_32[j] >> 8) & 0xFF) / 255.0f * 2 - 1;
normals[j].z() = ((n_32[j] >> 16) & 0xFF) / 255.0f * 2 - 1;
}
}
else
{
BOOST_ASSERT(EF_ARGB8 == rl.VertexStreamFormat(i)[0].format);
for (uint32_t j = 0; j < total_num_vertices; ++ j)
{
normals[j].x() = ((n_32[j] >> 16) & 0xFF) / 255.0f * 2 - 1;
normals[j].y() = ((n_32[j] >> 8) & 0xFF) / 255.0f * 2 - 1;
normals[j].z() = ((n_32[j] >> 0) & 0xFF) / 255.0f * 2 - 1;
}
}
}
break;
case VEU_Tangent:
{
GraphicsBufferPtr vb_cpu = rf.MakeVertexBuffer(BU_Static, EAH_CPU_Read, vb->Size(), nullptr);
vb->CopyToBuffer(*vb_cpu);
GraphicsBuffer::Mapper mapper(*vb_cpu, BA_Read_Only);
uint32_t const * t_32 = mapper.Pointer<uint32_t>();
if (EF_ABGR8 == rl.VertexStreamFormat(i)[0].format)
{
for (uint32_t j = 0; j < total_num_vertices; ++ j)
{
tangent_quats[j].x() = ((t_32[j] >> 0) & 0xFF) / 255.0f * 2 - 1;
tangent_quats[j].y() = ((t_32[j] >> 8) & 0xFF) / 255.0f * 2 - 1;
tangent_quats[j].z() = ((t_32[j] >> 16) & 0xFF) / 255.0f * 2 - 1;
tangent_quats[j].w() = ((t_32[j] >> 24) & 0xFF) / 255.0f * 2 - 1;
}
}
else
{
BOOST_ASSERT(EF_ARGB8 == rl.VertexStreamFormat(i)[0].format);
for (uint32_t j = 0; j < total_num_vertices; ++ j)
{
tangent_quats[j].x() = ((t_32[j] >> 16) & 0xFF) / 255.0f * 2 - 1;
tangent_quats[j].y() = ((t_32[j] >> 8) & 0xFF) / 255.0f * 2 - 1;
tangent_quats[j].z() = ((t_32[j] >> 0) & 0xFF) / 255.0f * 2 - 1;
tangent_quats[j].w() = ((t_32[j] >> 24) & 0xFF) / 255.0f * 2 - 1;
}
}
}
void XAAudioEngine::SetListenerOri(float3 const & face, float3 const & up)
{
listener_.OrientFront = { face.x(), face.y(), face.z() };
listener_.OrientTop = { up.x(), up.y(), up.z() };
}
void XAAudioEngine::SetListenerVel(float3 const & v)
{
listener_.Velocity = { v.x(), v.y(), v.z() };
}
void ClearFrameBuffer(const float3 &c)
{
glClearColor(c.x(), c.y(), c.z(), 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
// 获取3D听者方向
/////////////////////////////////////////////////////////////////////////////////
void DSAudioEngine::SetListenerOri(float3 const & face, float3 const & up)
{
this->ds3dListener_->SetOrientation(face.x(), face.y(), face.z(),
up.x(), up.y(), up.z(), DS3D_IMMEDIATE);
}
float3 ALVecToVec(float3 const & v)
{
return float3(v.x(), v.y(), -v.z());
}
void XAAudioEngine::SetListenerPos(float3 const & v)
{
listener_.Position = { v.x(), v.y(), v.z() };
}
Mat44 Mat44::BuildRotationMatrix(const f32 angle_in_degrees, const float3& axis)
{
return BuildRotationMatrix(angle_in_degrees, axis.x(), axis.y(), axis.z());
};
