void Transform::invalidate(bool rotationUpdated) {
if (model_matrix_.isValid()) {
model_matrix_.invalidate();
std::vector<SceneObject*> childrenCopy = owner_object()->children();
for (auto it = childrenCopy.begin(); it != childrenCopy.end(); ++it) {
Transform* const t = (*it)->transform();
if (nullptr != t) {
t->invalidate(false);
}
}
}
if (rotationUpdated) {
// scale rotation_ if needed to avoid overflow
static const float threshold = sqrt(FLT_MAX) / 2.0f;
static const float scale_factor = 0.5f / sqrt(FLT_MAX);
if (rotation_.w > threshold || rotation_.x > threshold
|| rotation_.y > threshold || rotation_.z > threshold) {
rotation_.w *= scale_factor;
rotation_.x *= scale_factor;
rotation_.y *= scale_factor;
rotation_.z *= scale_factor;
}
}
if(owner_object()) {
owner_object()->dirtyHierarchicalBoundingVolume();
}
}
void BulletGeneric6dofConstraint::updateConstructionInfo() {
if (mGeneric6DofConstraint != 0) {
delete (mGeneric6DofConstraint);
}
btRigidBody *rbA = ((BulletRigidBody*)owner_object()->
getComponent(COMPONENT_TYPE_PHYSICS_RIGID_BODY))->getRigidBody();
btVector3 p(mPosition.x, mPosition.y, mPosition.z);
btMatrix3x3 m(mRotationA.vec[0], mRotationA.vec[1], mRotationA.vec[2], mRotationA.vec[3],
mRotationA.vec[4], mRotationA.vec[5], mRotationA.vec[6], mRotationA.vec[7],
mRotationA.vec[8]);
btTransform fA(m, p);
p = rbA->getWorldTransform().getOrigin() + p;
p -= mRigidBodyB->getRigidBody()->getWorldTransform().getOrigin();
m.setValue(mRotationB.vec[0], mRotationB.vec[1], mRotationB.vec[2], mRotationB.vec[3],
mRotationB.vec[4], mRotationB.vec[5], mRotationB.vec[6], mRotationB.vec[7],
mRotationB.vec[8]);
btTransform fB(m, p);
mGeneric6DofConstraint =
new btGeneric6DofConstraint(*rbA, *mRigidBodyB->getRigidBody(), fA, fB, false);
mGeneric6DofConstraint->setLinearLowerLimit(Common2Bullet(mLinearLowerLimits));
mGeneric6DofConstraint->setLinearUpperLimit(Common2Bullet(mLinearUpperLimits));
mGeneric6DofConstraint->setAngularLowerLimit(Common2Bullet(mAngularLowerLimits));
mGeneric6DofConstraint->setAngularUpperLimit(Common2Bullet(mAngularUpperLimits));
mGeneric6DofConstraint->setBreakingImpulseThreshold(mBreakingImpulse);
}
ColliderData ColliderGroup::isHit(const glm::vec3& rayStart, const glm::vec3& rayDir)
{
ColliderData finalHit(reinterpret_cast<Collider *>(this));
SceneObject *ownerObject = owner_object();
hit_ = glm::vec3(std::numeric_limits<float>::infinity());
if (nullptr != ownerObject)
{
Transform *transform = ownerObject->transform();
finalHit.ObjectHit = ownerObject;
if (nullptr != transform)
{
glm::mat4 model_inverse = glm::affineInverse(transform->getModelMatrix());
glm::vec3 O(rayStart);
glm::vec3 D(rayDir);
transformRay(model_inverse, O, D);
for (auto it = colliders_.begin(); it != colliders_.end(); ++it)
{
ColliderData currentHit = (*it)->isHit(O, D);
if (currentHit.IsHit && (currentHit.Distance < finalHit.Distance))
{
hit_ = currentHit.HitPosition;
finalHit.CopyHit(currentHit);
}
}
}
}
return finalHit;
}
glm::vec3 CameraRig::getLookAt() const {
glm::mat4 model_matrix = owner_object()->transform()->getModelMatrix();
float x0 = model_matrix[3][0];
float y0 = model_matrix[3][1];
float z0 = model_matrix[3][2];
float reciprocalW0 = 1 / model_matrix[3][3];
x0 *= reciprocalW0;
y0 *= reciprocalW0;
z0 *= reciprocalW0;
float x1 = model_matrix[2][0] * -1.0f + model_matrix[3][0];
float y1 = model_matrix[2][1] * -1.0f + model_matrix[3][1];
float z1 = model_matrix[2][2] * -1.0f + model_matrix[3][2];
float reciprocalW1 = 1.0f
/ (model_matrix[2][3] * -1.0f + model_matrix[3][3]);
x1 *= reciprocalW1;
y1 *= reciprocalW1;
z1 *= reciprocalW1;
float lookAtX = x1 - x0;
float lookAtY = y1 - y0;
float lookAtZ = z1 - z0;
float reciprocalLength = 1.0f
/ sqrtf(lookAtX * lookAtX + lookAtY * lookAtY + lookAtZ * lookAtZ);
lookAtX *= reciprocalLength;
lookAtY *= reciprocalLength;
lookAtZ *= reciprocalLength;
return glm::vec3(lookAtX, lookAtY, lookAtZ);
}
void Transform::invalidate() {
if (model_matrix_.isValid()) {
model_matrix_.invalidate();
std::vector<SceneObject*> children(owner_object()->children());
for (auto it = children.begin(); it != children.end(); ++it) {
(*it)->transform()->invalidate();
}
}
}
glm::mat4 Transform::getModelMatrix() {
if (!model_matrix_.isValid()) {
glm::mat4 translation_matrix = glm::translate(glm::mat4(), position_);
glm::mat4 rotation_matrix = glm::mat4_cast(rotation_);
glm::mat4 scale_matrix = glm::scale(glm::mat4(), scale_);
glm::mat4 trs_matrix = translation_matrix * rotation_matrix
* scale_matrix;
if (owner_object()->parent() != 0) {
glm::mat4 model_matrix =
owner_object()->parent()->transform()->getModelMatrix()
* trs_matrix;
model_matrix_.validate(model_matrix);
} else {
model_matrix_.validate(trs_matrix);
}
}
return model_matrix_.element();
}
void SceneObject::attachCameraRig(SceneObject* self, CameraRig* camera_rig) {
if (camera_rig_) {
detachCameraRig();
}
SceneObject* owner_object(camera_rig->owner_object());
if (owner_object) {
owner_object->detachCameraRig();
}
camera_rig_ = camera_rig;
camera_rig_->set_owner_object(self);
}
void SceneObject::attachCamera(SceneObject* self, Camera* camera) {
if (camera_) {
detachCamera();
}
SceneObject* owner_object(camera->owner_object());
if (owner_object) {
owner_object->detachCamera();
}
camera_ = camera;
camera_->set_owner_object(self);
}
void SceneObject::attachTransform(SceneObject* self, Transform* transform) {
if (transform_) {
detachTransform();
}
SceneObject* owner_object(transform->owner_object());
if (owner_object) {
owner_object->detachRenderData();
}
transform_ = transform;
transform_->set_owner_object(self);
dirtyBoundingVolume();
}
void SceneObject::attachRenderData(SceneObject* self, RenderData* render_data) {
if (render_data_) {
detachRenderData();
}
SceneObject* owner_object(render_data->owner_object());
if (owner_object) {
owner_object->detachRenderData();
}
render_data_ = render_data;
render_data->set_owner_object(self);
dirtyBoundingVolume();
}
void SceneObject::attachCameraRig(const std::shared_ptr<SceneObject>& self,
const std::shared_ptr<CameraRig>& camera_rig) {
if (camera_rig_) {
detachCameraRig();
}
std::shared_ptr<SceneObject> owner_object(camera_rig->owner_object());
if (owner_object) {
owner_object->detachCameraRig();
}
camera_rig_ = camera_rig;
camera_rig_->set_owner_object(self);
}
void SceneObject::attachCamera(const std::shared_ptr<SceneObject>& self,
const std::shared_ptr<Camera>& camera) {
if (camera_) {
detachCamera();
}
std::shared_ptr<SceneObject> owner_object(camera->owner_object());
if (owner_object) {
owner_object->detachCamera();
}
camera_ = camera;
camera_->set_owner_object(self);
}
void SceneObject::attachRenderData(const std::shared_ptr<SceneObject>& self,
const std::shared_ptr<RenderData>& render_data) {
if (render_data_) {
detachRenderData();
}
std::shared_ptr<SceneObject> owner_object(render_data->owner_object());
if (owner_object) {
owner_object->detachRenderData();
}
render_data_ = render_data;
render_data->set_owner_object(self);
}
void SceneObject::attachTransform(const std::shared_ptr<SceneObject>& self,
const std::shared_ptr<Transform>& transform) {
if (transform_) {
detachTransform();
}
std::shared_ptr<SceneObject> owner_object(transform->owner_object());
if (owner_object) {
owner_object->detachRenderData();
}
transform_ = transform;
transform_->set_owner_object(self);
}
EyePointData EyePointeeHolder::isPointed(const glm::mat4& view_matrix, float ox,
float oy, float oz, float dx, float dy, float dz) {
glm::mat4 mv_matrix = view_matrix
* owner_object()->transform()->getModelMatrix();
EyePointData holder_data;
for (auto it = pointees_.begin(); it != pointees_.end(); ++it) {
EyePointData data = (*it)->isPointed(mv_matrix, ox, oy, oz, dx, dy, dz);
if (data.distance() < holder_data.distance()) {
holder_data = data;
}
}
return holder_data;
}
void SceneObject::attachEyePointeeHolder(
SceneObject* self,
EyePointeeHolder* eye_pointee_holder) {
if (eye_pointee_holder_) {
detachEyePointeeHolder();
}
SceneObject* owner_object(eye_pointee_holder->owner_object());
if (owner_object) {
owner_object->detachEyePointeeHolder();
}
eye_pointee_holder_ = eye_pointee_holder;
eye_pointee_holder_->set_owner_object(self);
}
void CameraRig::predict(float time) {
long long clock_time = getCurrentTime();
float time_diff = (clock_time - rotation_sensor_data_.time_stamp())
/ 1000000000.0f;
glm::vec3 axis = rotation_sensor_data_.gyro();
float angle = glm::length(axis);
if (angle != 0.0f) {
axis /= angle;
}
angle *= (time + time_diff) * 180.0f / M_PI;
glm::quat rotation = rotation_sensor_data_.quaternion()
* glm::angleAxis(angle, axis);
glm::quat transfrom_rotation = complementary_rotation_ * rotation;
if (camera_rig_type_ == FREE) {
owner_object()->transform()->set_rotation(transfrom_rotation);
} else if (camera_rig_type_ == YAW_ONLY) {
glm::vec3 look_at = glm::rotate(transfrom_rotation,
glm::vec3(0.0f, 0.0f, -1.0f));
float yaw = atan2f(-look_at.x, -look_at.z) * 180.0f / M_PI;
owner_object()->transform()->set_rotation(
glm::angleAxis(yaw, glm::vec3(0.0f, 1.0f, 0.0f)));
} else if (camera_rig_type_ == ROLL_FREEZE) {
glm::vec3 look_at = glm::rotate(transfrom_rotation,
glm::vec3(0.0f, 0.0f, -1.0f));
float pitch = atan2f(look_at.y,
sqrtf(look_at.x * look_at.x + look_at.z * look_at.z)) * 180.0f
/ M_PI;
float yaw = atan2f(-look_at.x, -look_at.z) * 180.0f / M_PI;
owner_object()->transform()->set_rotation(
glm::angleAxis(pitch, glm::vec3(1.0f, 0.0f, 0.0f)));
owner_object()->transform()->rotateByAxis(yaw, 0.0f, 1.0f, 0.0f);
} else if (camera_rig_type_ == FREEZE) {
owner_object()->transform()->set_rotation(glm::quat());
} else if (camera_rig_type_ == ORBIT_PIVOT) {
glm::vec3 pivot(getVec3("pivot"));
owner_object()->transform()->set_position(pivot.x, pivot.y,
pivot.z + getFloat("distance"));
owner_object()->transform()->set_rotation(glm::quat());
owner_object()->transform()->rotateWithPivot(transfrom_rotation.w,
transfrom_rotation.x, transfrom_rotation.y,
transfrom_rotation.z, pivot.x, pivot.y, pivot.z);
}
}
void BulletRigidBody::updateColisionShapeLocalScaling() {
btVector3 ownerScale;
SceneObject* owner = owner_object();
if (owner) {
Transform* trans = owner->transform();
ownerScale.setValue(trans->scale_x(),
trans->scale_y(),
trans->scale_z());
} else {
ownerScale.setValue(1.0f, 1.0f, 1.0f);
}
mRigidBody->getCollisionShape()->setLocalScaling(mScale * ownerScale);
}
void SceneObject::attachEyePointeeHolder(
const std::shared_ptr<SceneObject>& self,
const std::shared_ptr<EyePointeeHolder>& eye_pointee_holder) {
if (eye_pointee_holder_) {
detachEyePointeeHolder();
}
std::shared_ptr<SceneObject> owner_object(
eye_pointee_holder->owner_object());
if (owner_object) {
owner_object->detachEyePointeeHolder();
}
eye_pointee_holder_ = eye_pointee_holder;
eye_pointee_holder_->set_owner_object(self);
}
void BulletRigidBody::setWorldTransform(const btTransform ¢erOfMassWorldTrans) {
Transform* trans = owner_object()->transform();
btTransform aux; getWorldTransform(aux);
if(std::abs(aux.getOrigin().getX() - prevPos.getOrigin().getX()) >= 0.1f ||
std::abs(aux.getOrigin().getY() - prevPos.getOrigin().getY()) >= 0.1f ||
std::abs(aux.getOrigin().getZ() - prevPos.getOrigin().getZ()) >= 0.1f)
{
mRigidBody->setWorldTransform(aux);
prevPos = aux;
//TODO: incomplete solution
}
else
{
btTransform physicBody = (centerOfMassWorldTrans * m_centerOfMassOffset);
convertBtTransform2Transform(physicBody, trans);
prevPos = physicBody;
}
//convertBtTransform2Transform(centerOfMassWorldTrans * m_centerOfMassOffset, trans);
}
void GLRenderData::render(Shader* shader, Renderer* renderer)
{
GLShader* glshader = static_cast<GLShader*>(shader);
int programId = glshader->getProgramId();
int indexCount = mesh_->getIndexCount();
int vertexCount = mesh_->getVertexCount();
int mode = draw_mode();
#ifdef DEBUG_SHADER
LOGV("SHADER: RenderData::render binding vertex arrays to program %d %p %d vertices, %d indices",
programId, this, vertexCount, indexCount);
#endif
if (shader->hasBones())
{
Skin* skin = (Skin*) owner_object()->getComponent(Skin::getComponentType());
if (skin)
{
skin->bindBuffer(renderer, shader);
}
}
mesh_->getVertexBuffer()->bindToShader(shader, mesh_->getIndexBuffer());
checkGLError("renderMesh::mesh_->getVertexBuffer()->bindToShader(");
switch (mesh_->getIndexSize())
{
case 2:
glDrawElements(mode, indexCount, GL_UNSIGNED_SHORT, 0);
break;
case 4:
glDrawElements(mode, indexCount, GL_UNSIGNED_INT, 0);
break;
default:
glDrawArrays(mode, 0, vertexCount);
break;
}
checkGLError(" RenderData::render after draw");
glBindVertexArray(0);
}
Transform* CameraRig::getHeadTransform() const {
return owner_object()->getChildByIndex(0)->transform();
}
void BulletRigidBody::getWorldTransform(btTransform ¢erOfMassWorldTrans) const {
Transform* trans = owner_object()->transform();
centerOfMassWorldTrans = convertTransform2btTransform(trans)
* m_centerOfMassOffset.inverse();
}
