void PolyhedronColliderGeometry::UpdateProxy(const RigidBody &body, Proxy &proxy)
{
if (body.mParent->cphy->mColliderType != 0 || body.mParent->cphy->gameObject->GetFlag("Kinetic"))
UpdateAABB(body, proxy);
else
{
if (mDoItOnce)
{
UpdateAABB(body, proxy);
mDoItOnce = false;
}
}
}
PointLight::PointLight(const LightBaseParams& baseParams,const Transform& transform, float radius)
:Light(baseParams)
,m_radius(radius)
,m_transform(transform)
{
UpdateAABB();
}
void BoxShape::UpdatePosition(glm::vec2 change)
{
m_center.x += change.x;
m_center.y += change.y;
UpdateAABB();
}
/**
* function to move the character or ship to a relative position from the current position
*/
void CCharacter::MoveRelTo (Vector Move) ///Moving relative to the character current Position
{
///Adding relative movement
Position += Move;
///Updating the bounding box
UpdateAABB ();
}
/**
* function to move the character or ship to a position based on x, y, z units from the current position
*/
void CCharacter::MoveRelTo (float x, float y, float z) ///Moves x,y,z units from the to the current position
{
Position.v[X3D] += x; /// update the position x by increasing x units of the character
Position.v[Y3D] += y; /// update the position y by increasing y units of the character
Position.v[Z3D] += z; /// update the position z by increasing z units of the character
///Updating the bounding box
UpdateAABB ();
}
/**
* function to move to an absolute position to the character or ship to a position x, y, z
*/
void CCharacter::MoveTo (float x, float y, float z) ///Moves to the absolute coordinate x,y,z
{
Position.v[X3D] = x; //actualizar la posicion del caracter en el plano x
Position.v[Y3D] = y; //actualizar la posicion del caracter en el plano y
Position.v[Z3D] = z; //actualizar la posicion del caracter en el plano z
///Updating the bounding box
UpdateAABB ();
}
BoxShape::BoxShape(float x, float y, float w, float h, int angle)
{
m_center.x = x + w/2;
m_center.y = y + h/2;
m_width = w;
m_height = h;
m_angle = angle;
UpdateAABB();
}
bool MovingEntity::HorizontalColision(Vector3 pos)
{
bool colided = false;
GatherBlockPositions(pos);
for (int i = 0;i < 36;i++)
{
BlockPosition *bp = &_blockPositions[i];
if (_world->IsBlockCollidable(bp->position.x,bp->position.y,bp->position.z))
{
BoundingBox blockBox = BoundingBox(Vector3(bp->position.x,bp->position.y,bp->position.z),Vector3(bp->position.x+1,bp->position.y+1,bp->position.z+1));
if (_aabb.intersect(blockBox))
{
colided = true;
Vector3 direction = Vector3(_position.x, 0.0f, _position.z);
direction.x -= pos.x;
direction.z -= pos.z;
// Calculate the point of intersection on the block's AABB
Vector3 blockPoi = blockBox.ClosestPointTo(pos);
BoundingBox newAABB = BoundingBox(Vector3(pos.x - _downSize.x,pos.y - _downSize.y,pos.z - _downSize.z),Vector3(pos.x + _upSize.x,pos.y + _upSize.y,pos.z +_upSize.z));
Vector3 entityPoi = newAABB.ClosestPointTo(blockPoi);
Vector3 planeNormal = blockBox.getFirstHitPlane(direction, pos, _aabb.getDimension(), true, false, true);
// Find a vector parallel to the surface normal
Vector3 slideVector = Vector3(planeNormal.z, 0, -planeNormal.x);
Vector3 pushBack = blockPoi - entityPoi;
// Calculate the intensity of the diversion alongside the block
double length = Vector3::dot(slideVector,direction);
Vector3 newPosition;
newPosition.z = pos.z + pushBack.z * 0.2f + length * slideVector.z;
newPosition.x = pos.x + pushBack.x * 0.2f + length * slideVector.x;
newPosition.y = _position.y;
_position = newPosition;
UpdateAABB();
}
}
}
return colided;
}
void CalculateAABB(const sreBoundingVolumeCylinder& cylinder, sreBoundingVolumeAABB& AABB) {
AABB.dim_min = AABB.dim_max = cylinder.center;
for (float factor = - 0.5f; factor < 1.0f; factor += 1.0f) {
UpdateAABB(AABB, cylinder.center + factor * cylinder.length * cylinder.axis + cylinder.radius *
Vector3D(-1.0f, 0, 0) * (1.0f - Dot(cylinder.axis, Vector3D(-1.0f, 0, 0))));
UpdateAABB(AABB, cylinder.center + factor * cylinder.length * cylinder.axis + cylinder.radius *
Vector3D(1.0f, 0, 0) * (1.0f - Dot(cylinder.axis, Vector3D(1.0f, 0, 0))));
UpdateAABB(AABB, cylinder.center + factor * cylinder.length * cylinder.axis + cylinder.radius *
Vector3D(0, -1.0f, 0) * (1.0f - Dot(cylinder.axis, Vector3D(0, -1.0f, 0))));
UpdateAABB(AABB, cylinder.center + factor * cylinder.length * cylinder.axis + cylinder.radius *
Vector3D(0, 1.0f, 0) * (1.0f - Dot(cylinder.axis, Vector3D(0, 1.0f, 0))));
UpdateAABB(AABB, cylinder.center + factor * cylinder.length * cylinder.axis + cylinder.radius *
Vector3D(0, 0, -1.0f) * (1.0f - Dot(cylinder.axis, Vector3D(0, 0, -1.0f))));
UpdateAABB(AABB, cylinder.center + factor * cylinder.length * cylinder.axis + cylinder.radius *
Vector3D(0, 0, 1.0f) * (1.0f - Dot(cylinder.axis, Vector3D(0, 0, 1.0f))));
}
#if 0
// Construct two spheres at the endpoints of the cylinder, and use the union of their AABBs.
// Should be optimized to exclude half of the spheres at the endpoint.
sreBoundingVolumeSphere endpoint_sphere;
endpoint_sphere.center = cylinder.center - cylinder.length * cylinder.axis * 0.5;
endpoint_sphere.radius = cylinder.radius;
AABB.dim_min = endpoint_sphere.center - Vector3D(endpoint_sphere.radius, endpoint_sphere.radius,
endpoint_sphere.radius);
AABB.dim_max = endpoint_sphere.center + Vector3D(endpoint_sphere.radius, endpoint_sphere.radius,
endpoint_sphere.radius);
endpoint_sphere.center = cylinder.center - cylinder.length * cylinder.axis * 0.5;
endpoint_sphere.radius = cylinder.radius;
sreBoundingVolumeAABB AABB_endpoint2;
AABB_endpoint2.dim_min = endpoint_sphere.center - Vector3D(endpoint_sphere.radius,
endpoint_sphere.radius, endpoint_sphere.radius);
AABB_endpoint2.dim_max = endpoint_sphere.center + Vector3D(endpoint_sphere.radius,
endpoint_sphere.radius, endpoint_sphere.radius);
UpdateAABB(AABB, AABB_endpoint2);
#endif
}
void cLight::Type( const LIGHT_TYPE& type ) {
mType = type;
UpdateAABB();
}
void cLight::Radius( const eeFloat& radius ) {
if ( radius > 0 ) {
mRadius = radius;
UpdateAABB();
}
}
void cLight::UpdatePos( const eeFloat& x, const eeFloat& y ) {
mPos.x = x;
mPos.y = y;
UpdateAABB();
}
/**
* @fn void CShoot::SubtypeChange(CSH_SHOOT_TYPE ShootType)
* Any subtype change changes AABB and size
* @ Param [in] ShootType Type of shoot
*/
void CShoot::SubtypeChange(CSH_SHOOT_TYPE ShootType)
{
SubType = ShootType;
if (CHAR_2D == RenderMode)
{
Size.v[XDIM] = 0.05f;
Size.v[YDIM] = 0.3f;
Size.v[ZDIM] = 0.0f;
}
else switch (SubType)
{
case CSH_PLAYER:
Health = 4; //Amount of power a player shoot may substract from the enemy
Size.v[XDIM] = 0.1f;
Size.v[YDIM] = 0.25f;
Size.v[ZDIM] = 0.0f;
break;
case CSH_PLAYER3D:
Health = 20; //Amount of power a player shoot on 3D mode may substract from the enemy
Size.v[XDIM] = 0.05f; //5.05 .1
Size.v[YDIM] = 0.3f; //.3 .25
Size.v[ZDIM] = 0.0f;
break;
case CSH_PLAYER3D_CHEVRON:
Health = 50; //Amount of power a player shoot on 3D mode Chevron may substract from the enemy
Size.v[XDIM] = 0.5f; //5.05
Size.v[YDIM] = 0.3f; //.3
Size.v[ZDIM] = 0.0f;
break;
case CSH_AUXILIAR_LASER:
Health = 30; //Amount of power a auxiliar player laser shoot on 3D mode may substract from the enemy
Size.v[XDIM] = 0.03f;
Size.v[YDIM] = 0.8f;
Size.v[ZDIM] = 0.0f;
if(Player[CurrentPlayer].ShootType == CSH_PLAYER3D_CHEVRON){
Health = 50; //Amount of power a auxiliar player laser shoot on 3D mode may substract from the enemy
Size.v[XDIM] = 0.1f;
Size.v[YDIM] = 0.8f;
Size.v[ZDIM] = 0.0f;
}
break;
case CSH_SHIP:
Health = 3; //Amount of power an enemy shoot may substract from the player
Size.v[XDIM] = .033f;
Size.v[YDIM] = 0.3f;
Size.v[ZDIM] = 0.0f;
break;
case CSH_CIRCLE_SHIP:
Health = 10; //Amount of power an enemy shoot may substract from the player
Size.v[XDIM] = .035f;
Size.v[YDIM] = 0.3f;
Size.v[ZDIM] = 0.0f;
break;
case CSH_SUPPLY_SHIP:
Health = 10; //Amount of power an enemy shoot may substract from the player
Size.v[XDIM] = .035f;
Size.v[YDIM] = 0.3f;
Size.v[ZDIM] = 0.0f;
break;
default:;
}
#ifdef CHAR_USE_AABB
UpdateAABB();
#endif
}
void PointLight::Update()
{
m_transform.UpdateMatrices();
SceneManager::GetInstance().GetCurrentScene()->UpdateAllPointLights();
UpdateAABB();
}
void MovingEntity::Update(float dt)
{
if (!_isRunning)
_activeMovementAcc = _movementAcceleration;
else if (_canFly)
_activeMovementAcc = _movementAcceleration * 4.0;
else
_activeMovementAcc = _movementAcceleration * _runningFactor;
_oldPosition = _position;
//slow down speed each pass
if (fabsf(_moveVelocity.y) > 0.0f)
{
_moveVelocity.y += -1.0f * _moveVelocity.y * _groundFristion * dt;
}
if (fabsf(_moveVelocity.x) > 0.0f)
{
_moveVelocity.x += -1.0f * _moveVelocity.x * _groundFristion * dt;
}
if (fabsf(_moveVelocity.z) > 0.0f)
{
_moveVelocity.z += -1.0f * _moveVelocity.z * _groundFristion * dt;
}
//friction
if (fabsf(_moveVelocity.x) > _activeMovementAcc || fabsf(_moveVelocity.z) > _activeMovementAcc || fabsf(_moveVelocity.y) > _activeMovementAcc)
{
float max = std::max(std::max(fabsf(_moveVelocity.x), fabsf(_moveVelocity.z)), fabsf(_moveVelocity.y));
float div = max / _activeMovementAcc;
if (div != 0.0f)
{
_moveVelocity.x /= div;
_moveVelocity.z /= div;
_moveVelocity.y /= div;
}
}
if (_moveDirection.magnitudeSq() > 0.0f)
{
_moveDirection.normalize();
}
_moveVelocity.x += _moveDirection.x * _activeMovementAcc;
_moveVelocity.y += _moveDirection.y * _activeMovementAcc;
_moveVelocity.z += _moveDirection.z * _activeMovementAcc;
if (_earthVelocity > -_maxAcceleration && !_canFly && !_isSwimming)
{
_earthVelocity -= _earthAcceleration * dt;
}
if (_earthVelocity < -_maxAcceleration && !_canFly && !_isSwimming)
{
_earthVelocity = -_maxAcceleration * dt;
}
// Pull the player down when swimming
/*if (!_canFly && _isSwimming)
{
_earthVelocity = -MAX_EARTH_ACC_WATER;
}*/
_position.y += (_moveVelocity.y + _earthVelocity) * dt;
if(_checkUpDownCollision())
{
float oldEarthVelocity = _earthVelocity;
_earthVelocity = 0;
if (oldEarthVelocity <= 0)
{
// Jumping is only possible, if the entity is standing on ground
if (_isJumping)
{
//playRandomFootstep();
_isJumping = false;
_earthVelocity = _jumpIntensity;
}
else if (!_onGround)
{
// Entity reaches the ground
//playRandomFootstep();
_onGround = true;
}
} else
{
_onGround = false;
}
}
else
{
_onGround = false;
}
if (_canFly)
{
_earthVelocity = 0.0f;
}
_position.x += _moveVelocity.x * dt;
_position.z += _moveVelocity.z * dt;
UpdateAABB();
if(HorizontalColision(_oldPosition))
{
if (_canAutostep && _onGround && !_canFly)
{
Vector3 testPos = _position + Vector3(0,-_downSize.y,0);
Vector3 testPos2 = _position + Vector3(0,-_downSize.y,0);
Vector3 velocityCopy = Vector3::normalized(_moveVelocity);
testPos.x = testPos.x < 0 ? testPos.x - 1 : testPos.x;
testPos.y = testPos.y < 0 ? testPos.y - 1 : testPos.y;
testPos.z = testPos.z < 0 ? testPos.z - 1 : testPos.z;
testPos2.x = testPos2.x < 0 ? testPos2.x - 1 : testPos2.x;
testPos2.y = testPos2.y < 0 ? testPos2.y - 1 : testPos2.y;
testPos2.z = testPos2.z < 0 ? testPos2.z - 1 : testPos2.z;
//first test if at normal y there is blocking block
testPos2.x += velocityCopy.x;
testPos2.z += velocityCopy.z;
//second test if at y+1 is non blocking block
testPos.x += velocityCopy.x;
testPos.z += velocityCopy.z;
testPos.y += 1.0f;
if (!_world->IsBlockCollidable(testPos.x,testPos.y,testPos.z) && _world->IsBlockCollidable(testPos2.x,testPos2.y,testPos2.z))
{
Jump();
}
}
}
/*_moveVelocity = _moveDirection * 4.0f * dt;
//first check collision with floor
_position.y = _position.y + _moveVelocity.y;
if(_checkUpDownCollision())
{
}
//now check collision with walls
_position.x = _position.x + _moveVelocity.x;
_position.z = _position.z + _moveVelocity.z;
UpdateAABB();
HorizontalColision(_oldPosition);*/
//reset move direction
_moveDirection.set(0,0,0);
_isWalking = false;
}
void CalculateAABB(const sreBoundingVolumeSphericalSector& spherical_sector, sreBoundingVolumeAABB& AABB) {
// The circular edge of the spherical cap, the entire top of the spherical cap, and the
// spherical sector center/origin (the light position) have to be included when
//calculating the AABB.
// Add the center.
AABB.dim_min = AABB.dim_max = spherical_sector.center;
// Extend the AABB to include the top of the spherical cap. Since the spherical cap is part
// of the sphere that the sector is based on, we calculate the angle (dot product) between
// the axis and the AABB dimension vectors and using that to project the axis onto or into
// the direction of the dimension vector, limiting the angle to the half angular size of
// the sector (in which case the projection ends at the circular ring of the cap).
UpdateAABB(AABB, spherical_sector.center + spherical_sector.radius * ProjectOntoWithLimit(
spherical_sector.axis, Vector3D(-1.0f, 0, 0), spherical_sector.cos_half_angular_size));
UpdateAABB(AABB, spherical_sector.center + spherical_sector.radius * ProjectOntoWithLimit(
spherical_sector.axis, Vector3D(1.0f, 0, 0), spherical_sector.cos_half_angular_size));
UpdateAABB(AABB, spherical_sector.center + spherical_sector.radius * ProjectOntoWithLimit(
spherical_sector.axis, Vector3D(0, -1.0f, 0), spherical_sector.cos_half_angular_size));
UpdateAABB(AABB, spherical_sector.center + spherical_sector.radius * ProjectOntoWithLimit(
spherical_sector.axis, Vector3D(0, 1.0f, 0), spherical_sector.cos_half_angular_size));
UpdateAABB(AABB, spherical_sector.center + spherical_sector.radius * ProjectOntoWithLimit(
spherical_sector.axis, Vector3D(0, 0, -1.0f), spherical_sector.cos_half_angular_size));
UpdateAABB(AABB, spherical_sector.center + spherical_sector.radius * ProjectOntoWithLimit(
spherical_sector.axis, Vector3D(0, 0, 1.0f), spherical_sector.cos_half_angular_size));
#if 0
// This piece of code is unnecessary, the circular edge should already have been included
// above when required.
// Calculate the center and radius of the circular edge of the spherical cap.
Point3D circle_center = spherical_sector.center + spherical_sector.axis *
spherical_sector.radius * (1.0f - spherical_sector.cos_half_angular_size);
float circle_radius = spherical_sector.radius * spherical_sector.sin_half_angular_size;
// Update the AABB with the circle's minimum and maximum bounds in each dimension.
UpdateAABB(AABB, circle_center + circle_radius * Vector3D(- 1.0f, 0, 0) *
(1.0f - Dot(spherical_sector.axis, Vector3D(- 1.0f, 0, 0))));
UpdateAABB(AABB, circle_center + circle_radius * Vector3D(1.0f, 0, 0) *
(1.0f - Dot(spherical_sector.axis, Vector3D(1.0f, 0, 0))));
UpdateAABB(AABB, circle_center + circle_radius * Vector3D(0, - 1.0f, 0) *
(1.0f - Dot(spherical_sector.axis, Vector3D(0, - 1.0f, 0))));
UpdateAABB(AABB, circle_center + circle_radius * Vector3D(0, 1.0f, 0) *
(1.0f - Dot(spherical_sector.axis, Vector3D(0, 1.0f, 0))));
UpdateAABB(AABB, circle_center + circle_radius * Vector3D(0, 0, - 1.0f) *
(1.0f - Dot(spherical_sector.axis, Vector3D(0, 0, - 1.0f))));
UpdateAABB(AABB, circle_center + circle_radius * Vector3D(0, 0, 1.0f) *
(1.0f - Dot(spherical_sector.axis, Vector3D(0, 0, 1.0f))));
#endif
}
/**
* function to move the character or ship to an absolute position from the current position
*/
void CCharacter::MoveTo (Vector Move) ///Moving to an absolute position. It does not matter where the character is
{
Position = Move; /// Update position vector based on the Move[x,y,z]
UpdateAABB (); ///Updating the bounding box
}
void BoxShape::SetPosition(glm::vec2 pos)
{
m_center = pos;
UpdateAABB();
}
void sreFrustum::Calculate() {
// Calculate eye-space frustum.
frustum_eye.hull.vertex[0].Set(nearD / e, (1 / ratio) * nearD / e, - nearD); // Near-top-right.
frustum_eye.hull.vertex[1].Set(- nearD / e, (1 / ratio) * nearD / e, - nearD); // Near-top-left.
frustum_eye.hull.vertex[2].Set(- nearD / e, - (1 / ratio) * nearD / e, - nearD); // Near-bottom-left.
frustum_eye.hull.vertex[3].Set(nearD / e, - (1 / ratio) * nearD / e, - nearD); // Near-bottom-right.
// farD is an arbitrary distance, we actually have an infinite view frustum.
frustum_eye.hull.vertex[4].Set(farD / e, (1 / ratio) * farD / e, - farD); // Far-top-right.
frustum_eye.hull.vertex[5].Set(- farD / e, (1 / ratio) * farD / e, - farD); // Far-top-left.
frustum_eye.hull.vertex[6].Set(- farD / e, - (1 / ratio) * farD / e, - farD); // Far-bottom-left
frustum_eye.hull.vertex[7].Set(farD / e, - (1 / ratio) * farD / e, - farD); // Far-bottom-right.
Matrix4D inverse_view_matrix = Inverse(sre_internal_view_matrix);
for (int i = 0; i < 8; i++)
frustum_world.hull.vertex[i] = (inverse_view_matrix * frustum_eye.hull.vertex[i]).GetPoint3D();
// Calculate the "centroid". Actually we have an infinite view frustum, but the "centroid" is
// guaranteed to be in the frustum. Use the sphere bounding volume of the frustum to store the centroid.
frustum_world.sphere.center.Set(0, 0, 0);
for (int i = 0; i < 8 ; i++)
frustum_world.sphere.center += frustum_world.hull.vertex[i];
frustum_world.sphere.center *= (float)1 / 8;
// Set the planes in eye space.
float a = 1 / ratio;
frustum_eye.plane[0].Set(0, 0, - 1.0, - nearD); // Near plane.
frustum_eye.plane[1].Set(e / sqrtf(e * e + 1), 0, - 1 / sqrtf(e * e + 1), 0); // Left plane.
frustum_eye.plane[2].Set(- e / sqrtf(e * e + 1), 0, - 1 / sqrtf(e * e + 1), 0); // Right plane.
frustum_eye.plane[3].Set(0, e / sqrtf(e * e + a * a), - a / sqrtf(e * e + a * a), 0); // Bottom plane.
frustum_eye.plane[4].Set(0, - e / sqrtf(e * e + a * a), - a / sqrtf(e * e + a * a), 0); // Top plane.
frustum_eye.plane[5].Set(0, 0, 1.0, farD);
// Convert the planes to world space.
Matrix4D transpose_view_matrix = Transpose(sre_internal_view_matrix);
dstMatrixMultiplyVectors1xN(6, transpose_view_matrix, &frustum_eye.plane[0],
&frustum_world.plane[0]);
// for (int i = 0; i < 5; i++)
// printf("plane_world[%d] = (%f, %f, %f, %f)\n", i, plane_world[i].K.x, plane_world[i].K.y, plane_world[i].K.z,
// plane_world[i].K.w);
// Adjust the number of planes for intersection checks, if SRE_NU_FRUSTUM_PLANES is equal to 5 we don't use the far plane.
frustum_world.nu_planes = SRE_NU_FRUSTUM_PLANES;
frustum_eye.nu_planes = SRE_NU_FRUSTUM_PLANES;
#if SRE_NU_FRUSTUM_PLANES == 6
// Calculate the bounding sphere if there is a far plane.
frustum_world.sphere.radius = Magnitude(frustum_world.hull.vertex[4] - frustum_world.sphere.center);
// When there is a far plane, define a special reduced frustum without a far plane.
frustum_without_far_plane_world = frustum_world; // Copy fields.
frustum_without_far_plane_world.nu_planes = 5;
#endif
#ifndef NO_SHADOW_MAP
// Set the shadow map region for directional lights.
if (sre_internal_shadows == SRE_SHADOWS_SHADOW_MAPPING) {
Point3DPadded vertex[8], vertex2[8];
sreBoundingVolumeAABB AABB = sre_internal_shadow_map_AABB;
vertex[0] = Point3DPadded(AABB.dim_min.x, AABB.dim_min.y, AABB.dim_min.z);
vertex[1] = Point3DPadded(AABB.dim_max.x, AABB.dim_min.y, AABB.dim_min.z);
vertex[2] = Point3DPadded(AABB.dim_min.x, AABB.dim_max.y, AABB.dim_min.z);
vertex[3] = Point3DPadded(AABB.dim_max.x, AABB.dim_max.y, AABB.dim_min.z);
vertex[4] = Point3DPadded(AABB.dim_min.x, AABB.dim_min.y, AABB.dim_max.z);
vertex[5] = Point3DPadded(AABB.dim_max.x, AABB.dim_min.y, AABB.dim_max.z);
vertex[6] = Point3DPadded(AABB.dim_min.x, AABB.dim_max.y, AABB.dim_max.z);
vertex[7] = Point3DPadded(AABB.dim_max.x, AABB.dim_max.y, AABB.dim_max.z);
dstMatrixMultiplyVectors1xN(8, inverse_view_matrix, vertex, vertex2);
sreBoundingVolumeAABB empty_AABB;
empty_AABB.dim_min =
Point3D(FLT_MAX, FLT_MAX, FLT_MAX);
empty_AABB.dim_max =
Point3D(- FLT_MAX, - FLT_MAX, - FLT_MAX);
#ifdef USE_SIMD
sreBoundingVolumeAABB_SIMD region_AABB;
region_AABB.Set(empty_AABB);
#else
sreBoundingVolumeAABB region_AABB = empty_AABB;
#endif
for (int i = 0; i < 8; i++)
UpdateAABB(region_AABB, vertex2[i]);
#ifdef USE_SIMD
region_AABB.Get(shadow_map_region_AABB);
#else
shadow_map_region_AABB = region_AABB;
#endif
#if 0
sreMessage(SRE_MESSAGE_LOG, "Shadow map region AABB = (%f, %f, %f) - (%f, %f, %f)\n",
shadow_map_region_AABB.dim_min.x, shadow_map_region_AABB.dim_min.y, shadow_map_region_AABB.dim_min.z,
shadow_map_region_AABB.dim_max.x, shadow_map_region_AABB.dim_max.y, shadow_map_region_AABB.dim_max.z);
#endif
}
#endif
// Set information indicating when the frustum has changed.
if (most_recent_frame_changed == sre_internal_current_frame - 1)
changing_every_frame = true;
// Before to setting changing_every_frame to false, have to check that
// the frustum wasn't changed already this frame.
else if (most_recent_frame_changed != sre_internal_current_frame)
changing_every_frame = false;
most_recent_frame_changed = sre_internal_current_frame;
}
