void Rigidbody::Update(float dt) {
Transform *transform = _entity->GetTransform();
Vec2 v = vel * dt;
Vector<RayPointData> rays;
float eps = 0.01f;
for (int i = 0; i < _xPoints + 2; i++) {
float x = transform->pos.x + eps + (transform->size.x - 2 * eps) * i / (_xPoints + 1);
if (v.y <= 0.0f) {
rays.push_back({ { x, transform->pos.y }, { 0.0f, v.y }, CD_Up });
}
if (v.y >= 0.0f) {
CollisionDirection dir = CD_Down;
if (i == 0) {
dir = (CollisionDirection)(dir | CD_DownLeftSide);
}
else if (i == _xPoints + 1) {
dir = (CollisionDirection)(dir | CD_DownRightSide);
}
rays.push_back({ { x, transform->pos.y + transform->size.y }, { 0.0f, v.y }, dir });
}
}
for (int i = 0; i < _yPoints + 2; i++) {
float y = transform->pos.y + eps + (transform->size.y - 2 * eps) * i / (_yPoints + 1);
if (v.x <= 0.0f) {
rays.push_back({ { transform->pos.x, y }, { v.x, 0.0f }, CD_Left });
}
if (v.x >= 0.0f) {
rays.push_back({ { transform->pos.x + transform->size.x, y }, { v.x, 0.0f }, CD_Right });
}
}
Collider *collider = GetComponent<Collider>();
_collidedDirs = CD_None;
static int frame = 0;
frame++;
for (auto r : rays) {
float dist = FLT_MAX;
if (collider->Raycast(r.pos, r.pos + r.dir, &dist, _layerMask)) {
_collidedDirs = (CollisionDirection)(_collidedDirs | r.colDir);
if (r.colDir & CD_Horizontal) {
v.x = absMin(v.x, dist * sign1(v.x));
}
else {
v.y = absMin(v.y, dist * sign1(v.y));
}
}
}
if (_collidedDirs & CD_Vertical) {
vel.y = 0.0f;
}
if (!(_collidedDirs & CD_Down)) {
vel.y += kGravity * dt;
}
transform->pos += v;
}
//----------------------------------------------------------------------------//
Sizef Element::calculatePixelSize(bool skipAllPixelAlignment) const
{
// calculate pixel sizes for everything, so we have a common format for
// comparisons.
Sizef absMin(CoordConverter::asAbsolute(d_minSize,
getRootContainerSize(), false));
Sizef absMax(CoordConverter::asAbsolute(d_maxSize,
getRootContainerSize(), false));
Sizef base_size;
if (skipAllPixelAlignment)
{
base_size = Sizef((d_parent && !d_nonClient) ?
d_parent->getUnclippedInnerRect().getFresh(true).getSize() :
getParentPixelSize(true));
}
else
{
base_size = Sizef((d_parent && !d_nonClient) ?
d_parent->getUnclippedInnerRect().get().getSize() :
getParentPixelSize());
}
Sizef ret = CoordConverter::asAbsolute(d_area.getSize(), base_size, false);
// in case absMin components are larger than absMax ones,
// max size takes precedence
if (absMax.d_width != 0.0f && absMin.d_width > absMax.d_width)
{
absMin.d_width = absMax.d_width;
CEGUI_LOGINSANE("MinSize resulted in an absolute pixel size with "
"width larger than what MaxSize resulted in");
}
if (absMax.d_height != 0.0f && absMin.d_height > absMax.d_height)
{
absMin.d_height = absMax.d_height;
CEGUI_LOGINSANE("MinSize resulted in an absolute pixel size with "
"height larger than what MaxSize resulted in");
}
// limit new pixel size to: minSize <= newSize <= maxSize
if (ret.d_width < absMin.d_width)
ret.d_width = absMin.d_width;
else if (absMax.d_width != 0.0f && ret.d_width > absMax.d_width)
ret.d_width = absMax.d_width;
if (ret.d_height < absMin.d_height)
ret.d_height = absMin.d_height;
else if (absMax.d_height != 0.0f && ret.d_height > absMax.d_height)
ret.d_height = absMax.d_height;
if (d_aspectMode != AM_IGNORE)
{
// make sure we respect current aspect mode and ratio
ret.scaleToAspect(d_aspectMode, d_aspectRatio);
// make sure we haven't blown any of the hard limits
// still maintain the aspect when we do this
if (d_aspectMode == AM_SHRINK)
{
float ratio = 1.0f;
// check that we haven't blown the min size
if (ret.d_width < absMin.d_width)
{
ratio = absMin.d_width / ret.d_width;
}
if (ret.d_height < absMin.d_height)
{
const float newRatio = absMin.d_height / ret.d_height;
if (newRatio > ratio)
ratio = newRatio;
}
ret.d_width *= ratio;
ret.d_height *= ratio;
}
else if (d_aspectMode == AM_EXPAND)
{
float ratio = 1.0f;
// check that we haven't blown the min size
if (absMax.d_width != 0.0f && ret.d_width > absMax.d_width)
{
ratio = absMax.d_width / ret.d_width;
}
if (absMax.d_height != 0.0f && ret.d_height > absMax.d_height)
{
const float newRatio = absMax.d_height / ret.d_height;
if (newRatio > ratio)
ratio = newRatio;
}
ret.d_width *= ratio;
ret.d_height *= ratio;
}
// NOTE: When the hard min max limits are unsatisfiable with the aspect lock mode,
// the result won't be limited by both limits!
}
if (d_pixelAligned)
{
ret.d_width = CoordConverter::alignToPixels(ret.d_width);
ret.d_height = CoordConverter::alignToPixels(ret.d_height);
}
return ret;
}
