kmVec3 Camera::project_point(ViewportID vid, const kmVec3& point) {
if(!scene_) {
throw LogicError("Passes a nullptr as a camera's Scene");
}
kglt::Viewport& viewport = scene_->window().viewport(vid);
kmVec3 tmp;
kmVec3Fill(&tmp, point.x, point.y, point.z);
kmVec3 result;
kmVec3MultiplyMat4(&tmp, &tmp, &view_matrix());
kmVec3MultiplyMat4(&tmp, &tmp, &projection_matrix());
tmp.x /= tmp.z;
tmp.y /= tmp.z;
float vp_width = viewport.width();
float vp_height = viewport.height();
result.x = (tmp.x + 1) * vp_width / 2.0;
result.y = (tmp.y + 1) * vp_height / 2.0;
return result;
}
kmVec3* kmVec3Transform(kmVec3* pOut, const kmVec3* pV, const kmMat4* pM)
{
/*
@deprecated Should intead use kmVec3MultiplyMat4
*/
return kmVec3MultiplyMat4(pOut, pV, pM);
}
void Mesh::transform_vertices(const smlt::Mat4& transform, bool include_submeshes) {
shared_data->move_to_start();
for(uint32_t i = 0; i < shared_data->count(); ++i) {
if(shared_data->specification().has_positions()) {
smlt::Vec3 v = shared_data->position_at<Vec3>(i);
kmVec3MultiplyMat4(&v, &v, &transform);
shared_data->position(v);
}
if(shared_data->specification().has_normals()) {
smlt::Vec3 n;
shared_data->normal_at(i, n);
kmVec3TransformNormal(&n, &n, &transform);
shared_data->normal(n.normalized());
}
shared_data->move_next();
}
shared_data->done();
if(include_submeshes) {
each([transform](const std::string& name, SubMesh* mesh) {
if(!mesh->uses_shared_vertices()) {
mesh->transform_vertices(transform);
}
});
}
}
/* \brief transform V3B object */
static void _glhckSkinBoneTransformObjectV3B(glhckObject *object)
{
unsigned int i, w;
kmMat4 bias, biasinv, scale, scaleinv;
static glhckVector3b zero = {0,0,0};
kmMat4Translation(&bias, object->geometry->bias.x, object->geometry->bias.y, object->geometry->bias.z);
kmMat4Scaling(&scale, object->geometry->scale.x, object->geometry->scale.y, object->geometry->scale.z);
kmMat4Inverse(&biasinv, &bias);
kmMat4Inverse(&scaleinv, &scale);
for (i = 0; i != object->numSkinBones; ++i) {
glhckSkinBone *skinBone = object->skinBones[i];
for (w = 0; w != skinBone->numWeights; ++w) {
glhckVertexWeight *weight = &skinBone->weights[w];
if (weight->vertexIndex >= (glhckIndexi)object->geometry->vertexCount)
continue;
memcpy(&object->geometry->vertices.v3b[weight->vertexIndex].vertex, &zero, sizeof(glhckVector3s));
memcpy(&object->geometry->vertices.v3b[weight->vertexIndex].normal, &zero, sizeof(glhckVector3s));
}
}
for (i = 0; i != object->numSkinBones; ++i) {
kmMat3 transformedNormal;
kmMat4 transformedVertex, transformedMatrix, offsetMatrix;
glhckSkinBone *skinBone = object->skinBones[i];
if (!skinBone->bone) continue;
kmMat4Multiply(&transformedMatrix, &biasinv, &skinBone->bone->transformedMatrix);
kmMat4Multiply(&transformedMatrix, &scaleinv, &transformedMatrix);
kmMat4Multiply(&offsetMatrix, &skinBone->offsetMatrix, &bias);
kmMat4Multiply(&offsetMatrix, &offsetMatrix, &scale);
kmMat4Multiply(&transformedVertex, &transformedMatrix, &offsetMatrix);
kmMat3AssignMat4(&transformedNormal, &transformedVertex);
for (w = 0; w != skinBone->numWeights; ++w) {
glhckVector3f bindVertex, bindNormal;
glhckVertexWeight *weight = &skinBone->weights[w];
if (weight->vertexIndex >= (glhckIndexi)object->geometry->vertexCount)
continue;
glhckSetV3(&bindVertex, &object->bindGeometry->vertices.v3b[weight->vertexIndex].vertex);
glhckSetV3(&bindNormal, &object->bindGeometry->vertices.v3b[weight->vertexIndex].normal);
kmVec3MultiplyMat4((kmVec3*)&bindVertex, (kmVec3*)&bindVertex, &transformedVertex);
kmVec3MultiplyMat3((kmVec3*)&bindNormal, (kmVec3*)&bindNormal, &transformedNormal);
object->geometry->vertices.v3b[weight->vertexIndex].vertex.x += bindVertex.x * weight->weight;
object->geometry->vertices.v3b[weight->vertexIndex].vertex.y += bindVertex.y * weight->weight;
object->geometry->vertices.v3b[weight->vertexIndex].vertex.z += bindVertex.z * weight->weight;
object->geometry->vertices.v3b[weight->vertexIndex].normal.x += bindNormal.x * weight->weight;
object->geometry->vertices.v3b[weight->vertexIndex].normal.y += bindNormal.y * weight->weight;
object->geometry->vertices.v3b[weight->vertexIndex].normal.z += bindNormal.z * weight->weight;
}
}
}
void SubMesh::transform_vertices(const smlt::Mat4& transformation) {
if(uses_shared_data_) {
throw std::logic_error("Tried to transform shared_data, use Mesh::transform_vertices instead");
}
vertex_data->move_to_start();
for(uint16_t i = 0; i < vertex_data->count(); ++i) {
smlt::Vec3 v = vertex_data->position_at<Vec3>(i);
kmVec3MultiplyMat4(&v, &v, &transformation);
vertex_data->position(v);
if(vertex_data->specification().has_normals()) {
smlt::Vec3 n;
vertex_data->normal_at(i, n);
kmVec3MultiplyMat4(&n, &n, &transformation);
vertex_data->normal(n.normalized());
}
vertex_data->move_next();
}
vertex_data->done();
}
kmVec3 Camera::project_point(const RenderTarget &target, const Viewport &viewport, const kmVec3& point) {
if(!window_) {
throw std::logic_error("Passed a nullptr as a camera's window");
}
kmVec3 tmp;
kmVec3Fill(&tmp, point.x, point.y, point.z);
kmVec3 result;
kmVec3MultiplyMat4(&tmp, &tmp, &view_matrix());
kmVec3MultiplyMat4(&tmp, &tmp, &projection_matrix());
tmp.x /= tmp.z;
tmp.y /= tmp.z;
float vp_width = viewport.width_in_pixels(target);
float vp_height = viewport.height_in_pixels(target);
result.x = (tmp.x + 1) * vp_width / 2.0;
result.y = (tmp.y + 1) * vp_height / 2.0;
return result;
}
kmVec3* kmMat4GetForwardVec3LH(kmVec3* pOut, const kmMat4* pIn)
{
kmVec3MultiplyMat4(pOut, &KM_VEC3_POS_Z, pIn);
kmVec3Normalize(pOut, pOut);
return pOut;
}
/** Extract the right vector from a 4x4 matrix. The result is
* stored in pOut. Returns pOut.
*/
kmVec3* kmMat4GetRightVec3(kmVec3* pOut, const kmMat4* pIn)
{
kmVec3MultiplyMat4(pOut, &KM_VEC3_POS_X, pIn);
kmVec3Normalize(pOut, pOut);
return pOut;
}
