kmVec3* kmPlaneGetIntersection(kmVec3* pOut, const kmPlane* p1, const kmPlane* p2, const kmPlane* p3) { kmVec3 n1, n2, n3, cross; kmVec3 r1, r2, r3; double denom = 0; kmVec3Fill(&n1, p1->a, p1->b, p1->c); kmVec3Fill(&n2, p2->a, p2->b, p2->c); kmVec3Fill(&n3, p3->a, p3->b, p3->c); kmVec3Cross(&cross, &n2, &n3); denom = kmVec3Dot(&n1, &cross); if (kmAlmostEqual(denom, 0.0)) { return NULL; } kmVec3Cross(&r1, &n2, &n3); kmVec3Cross(&r2, &n3, &n1); kmVec3Cross(&r3, &n1, &n2); kmVec3Scale(&r1, &r1, -p1->d); kmVec3Scale(&r2, &r2, p2->d); kmVec3Scale(&r3, &r3, p3->d); kmVec3Subtract(pOut, &r1, &r2); kmVec3Subtract(pOut, pOut, &r3); kmVec3Scale(pOut, pOut, 1.0 / denom); /*p = -d1 * ( n2.Cross ( n3 ) ) – d2 * ( n3.Cross ( n1 ) ) – d3 * ( n1.Cross ( n2 ) ) / denom;*/ return pOut; }
void CFCEditorGLWindow::UpdateCamera() { kmVec3 vec3Speed; kmVec3Fill(&vec3Speed, 1.0f, 1.0f, 1.0f); if ( SafeGetKeyStage(VK_SHIFT) ) { kmVec3Scale(&vec3Speed, &vec3Speed, 5.0F * 0.016F); } else { kmVec3Scale(&vec3Speed, &vec3Speed, 1.0F * 0.016F); } int type = CCamera::eCMT_NOMOVE; bool bPressA = SafeGetKeyStage('A'); bool bPressD = SafeGetKeyStage('D'); if ( bPressA || bPressD ) { type |= (1 << CCamera::eCMT_TRANVERSE); if (bPressA) { vec3Speed.x *= -1; } } bool bPressW = SafeGetKeyStage('W'); bool bPressS = SafeGetKeyStage('S'); if ( bPressW || bPressS ) { type |= (1 << CCamera::eCMT_STRAIGHT); if (bPressW) { vec3Speed.z *= -1; } } bool bPressUp = SafeGetKeyStage('Q'); bool bPressDown = SafeGetKeyStage('Z'); if ( bPressUp || bPressDown ) { type |= (1 << CCamera::eCMT_UPDOWN); if (bPressDown) { vec3Speed.y *= -1; } } bool bPressR = SafeGetKeyStage('R'); if (bPressR) { m_pCamera->ResetCamera(); } if (type != CCamera::eCMT_NOMOVE) { m_pCamera->Update(vec3Speed, type); } }
void GLAnimationCanvas::UpDateCamera() { kmVec3 vec3Speed; kmVec3Fill(&vec3Speed, 1.0f, 1.0f, 1.0f); if ( GetKeyState(KEY_SHIFT) ) { kmVec3Scale(&vec3Speed, &vec3Speed, 5.0F * 0.016F); } else { kmVec3Scale(&vec3Speed, &vec3Speed, 1.0F * 0.016F); } int type = CCamera::eCMT_NOMOVE; bool bPressA = GetKeyState(KEY_A); bool bPressD = GetKeyState(KEY_D); if ( bPressA || bPressD ) { type |= (1 << CCamera::eCMT_TRANVERSE); if (bPressA) { vec3Speed.x *= -1; } } bool bPressW = GetKeyState(KEY_W); bool bPressS = GetKeyState(KEY_S); if ( bPressW || bPressS ) { type |= (1 << CCamera::eCMT_STRAIGHT); if (bPressW) { vec3Speed.z *= -1; } } bool bPressUp = GetKeyState(KEY_Q); bool bPressDown = GetKeyState(KEY_Z); if ( bPressUp || bPressDown ) { type |= (1 << CCamera::eCMT_UPDOWN); if (bPressDown) { vec3Speed.y *= -1; } } if (type != CCamera::eCMT_NOMOVE) { CRenderManager::GetInstance()->GetCamera()->Update(vec3Speed, type); } }
kmBool kmRay3IntersectAABB3(const kmRay3* ray, const kmAABB3* aabb, kmVec3* intersection, kmScalar* distance) { //http://gamedev.stackexchange.com/a/18459/15125 kmVec3 rdir, dirfrac, diff; kmVec3Normalize(&rdir, &ray->dir); kmVec3Fill(&dirfrac, 1.0 / rdir.x, 1.0 / rdir.y, 1.0 / rdir.z); kmScalar t1 = (aabb->min.x - ray->start.x) * dirfrac.x; kmScalar t2 = (aabb->max.x - ray->start.x) * dirfrac.x; kmScalar t3 = (aabb->min.y - ray->start.y) * dirfrac.y; kmScalar t4 = (aabb->max.y - ray->start.y) * dirfrac.y; kmScalar t5 = (aabb->min.z - ray->start.z) * dirfrac.z; kmScalar t6 = (aabb->max.z - ray->start.z) * dirfrac.z; kmScalar tmin = kmMax(kmMax(kmMin(t1, t2), kmMin(t3, t4)), kmMin(t5, t6)); kmScalar tmax = kmMin(kmMin(kmMax(t1, t2), kmMax(t3, t4)), kmMax(t5, t6)); // if tmax < 0, ray (line) is intersecting AABB, but whole AABB is behind us if(tmax < 0) { return KM_FALSE; } // if tmin > tmax, ray doesn't intersect AABB if (tmin > tmax) { return KM_FALSE; } if(distance) *distance = tmin; if(intersection) { kmVec3Scale(&diff, &rdir, tmin); kmVec3Add(intersection, &ray->start, &diff); } return KM_TRUE; }
/** * Creates a plane from 3 points. The result is stored in pOut. * pOut is returned. */ kmPlane* const kmPlaneFromPoints(kmPlane* pOut, const kmVec3* p1, const kmVec3* p2, const kmVec3* p3) { /* v = (B − A) × (C − A) n = 1⁄|v| v Outa = nx Outb = ny Outc = nz Outd = −n⋅A */ kmVec3 n, v1, v2; kmVec3Subtract(&v1, p2, p1); //Create the vectors for the 2 sides of the triangle kmVec3Subtract(&v2, p3, p1); kmVec3Cross(&n, &v1, &v2); //Use the cross product to get the normal kmVec3Normalize(&n, &n); //Normalize it and assign to pOut->m_N pOut->a = n.x; pOut->b = n.y; pOut->c = n.z; pOut->d = kmVec3Dot(kmVec3Scale(&n, &n, -1.0), p1); return pOut; }
kmVec3* kmVec3ProjectOnToVec3(const kmVec3* pIn, const kmVec3* other, kmVec3* projection) { kmScalar scale = kmVec3Length(pIn) * kmVec3Dot(pIn, other); kmVec3Normalize(projection, other); kmVec3Scale(projection, projection, scale); return projection; }
kmBool kmRay3IntersectPlane(kmVec3* pOut, const kmRay3* ray, const kmPlane* plane) { //t = - (A*org.x + B*org.y + C*org.z + D) / (A*dir.x + B*dir.y + C*dir.z ) kmScalar d = (plane->a * ray->dir.x + plane->b * ray->dir.y + plane->c * ray->dir.z); if(d == 0) { return KM_FALSE; } kmScalar t = -(plane->a * ray->start.x + plane->b * ray->start.y + plane->c * ray->start.z + plane->d) / d; if(t < 0) { return KM_FALSE; } kmVec3 scaled_dir; kmVec3Scale(&scaled_dir, &ray->dir, t); kmVec3Add(pOut, &ray->start, &scaled_dir); return KM_TRUE; }
/** * Returns the vector passed in set to unit length * the result is stored in pOut. */ kmVec3* kmVec3Normalize(kmVec3* pOut, const kmVec3* pIn) { /* kmScalar l = 1.0f / kmVec3Length(pIn); kmVec3 v; v.x = pIn->x * l; v.y = pIn->y * l; v.z = pIn->z * l; pOut->x = v.x; pOut->y = v.y; pOut->z = v.z; return pOut;*/ const float magnitude = kmVec3Length(pIn); static const float epsilon = 0.00001f; if (magnitude > epsilon) { const float scale = 1.0f / magnitude; kmVec3Scale(pOut, pIn, scale); //_vmul(v1, scale); } return pOut; }
/** * Reflects a vector about a given surface normal. The surface normal is * assumed to be of unit length. */ kmVec3* kmVec3Reflect(kmVec3* pOut, const kmVec3* pIn, const kmVec3* normal) { kmVec3 tmp; kmVec3Scale(&tmp, normal, 2.0f * kmVec3Dot(pIn, normal)); kmVec3Subtract(pOut, pIn, &tmp); return pOut; }
kmVec3 AABB::getCenter() const { kmVec3 result; kmVec3Add(&result, &_min, &_max); kmVec3Scale(&result, &result, 0.5f); return result; }
kmVec3* kmQuaternionMultiplyVec3(kmVec3* pOut, const kmQuaternion* q, const kmVec3* v) { kmVec3 uv, uuv, qvec; qvec.x = q->x; qvec.y = q->y; qvec.z = q->z; kmVec3Cross(&uv, &qvec, v); kmVec3Cross(&uuv, &qvec, &uv); kmVec3Scale(&uv, &uv, (2.0f * q->w)); kmVec3Scale(&uuv, &uuv, 2.0f); kmVec3Add(pOut, v, &uv); kmVec3Add(pOut, pOut, &uuv); return pOut; }
kmVec3* kmVec3ProjectOnToPlane(kmVec3* pOut, const kmVec3* point, const struct kmPlane* plane) { kmVec3 N; kmVec3Fill(&N, plane->a, plane->b, plane->c); kmVec3Normalize(&N, &N); kmScalar distance = -kmVec3Dot(&N, point); kmVec3Scale(&N, &N, distance); kmVec3Add(pOut, point, &N); return pOut; }
void kmVec3OrthoNormalize(kmVec3* normal, kmVec3* tangent) { kmVec3 proj; kmVec3Normalize(normal, normal); kmVec3Scale(&proj, normal, kmVec3Dot(tangent, normal)); kmVec3Subtract(tangent, tangent, &proj); kmVec3Normalize(tangent, tangent); }
kmVec3* kmVec3ConstrainToSphereSurface(kmVec3* pOut, const kmVec3* pIn, const kmScalar radius, const kmVec3* origin) { kmScalar d = sqrtf(powf(pIn->x - origin->x, 2) + powf(pIn->y - origin->y, 2) + powf(pIn->z - origin->z, 2)); kmScalar a = radius / d; kmVec3Scale(pOut, pIn, a); return pOut; }
void BoundingBox::getCenter(kmVec3* dst) const { GP_ASSERT(dst); kmVec3Subtract(dst, &max, &min); //dst->set(min, max); //dst->scale(0.5f); kmVec3Scale(dst, dst, 0.5f); //dst->add(min); kmVec3Add(dst, dst, &min); return; }
kmVec3* kmVec3ProjectOnToVec3(const kmVec3* w, const kmVec3* v, kmVec3* projection) { kmVec3 unitW, unitV; kmVec3Normalize(&unitW, w); kmVec3Normalize(&unitV, v); kmScalar cos0 = kmVec3Dot(&unitW, &unitV); kmVec3Scale(projection, &unitV, kmVec3Length(w) * cos0); return projection; }
void CFCEditorGLWindow::OnMouseMidScroll( wxMouseEvent& event ) { kmVec3 vec3Speed; kmVec3Fill(&vec3Speed, SHIFTWHEELSPEED, SHIFTWHEELSPEED, SHIFTWHEELSPEED); if (event.GetWheelRotation() > 0) { m_pCamera->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT)); } else if (event.GetWheelRotation() < 0) { kmVec3Scale(&vec3Speed, &vec3Speed, -1.0f); m_pCamera->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT)); } }
kmBool kmRay3IntersectTriangle(const kmRay3* ray, const kmVec3* v0, const kmVec3* v1, const kmVec3* v2, kmVec3* intersection, kmVec3* normal, kmScalar* distance) { kmVec3 e1, e2, pvec, tvec, qvec, dir; kmScalar det, inv_det, u, v, t; kmVec3Normalize(&dir, &ray->dir); kmVec3Subtract(&e1, v1, v0); kmVec3Subtract(&e2, v2, v0); kmVec3Cross(&pvec, &dir, &e2); det = kmVec3Dot(&e1, &pvec); /* Backfacing, discard. */ if(det < kmEpsilon) { return KM_FALSE; } if(kmAlmostEqual(det, 0)) { return KM_FALSE; } inv_det = 1.0 / det; kmVec3Subtract(&tvec, &ray->start, v0); u = inv_det * kmVec3Dot(&tvec, &pvec); if(u < 0.0 || u > 1.0) { return KM_FALSE; } kmVec3Cross(&qvec, &tvec, &e1); v = inv_det * kmVec3Dot(&dir, &qvec); if(v < 0.0 || (u + v) > 1.0) { return KM_FALSE; } t = inv_det * kmVec3Dot(&e2, &qvec); if(t > kmEpsilon && (t*t) <= kmVec3LengthSq(&ray->dir)) { kmVec3 scaled; *distance = t; /* Distance */ kmVec3Cross(normal, &e1, &e2); /* Surface normal of collision */ kmVec3Normalize(normal, normal); kmVec3Normalize(&scaled, &dir); kmVec3Scale(&scaled, &scaled, *distance); kmVec3Add(intersection, &ray->start, &scaled); return KM_TRUE; } return KM_FALSE; }
/* \brief cast a ray from camera at specified relative coordinate */ GLHCKAPI kmRay3* glhckCameraCastRayFromPoint(glhckCamera *object, kmRay3 *pOut, const kmVec2 *point) { CALL(2, "%p, "VEC2S, pOut, VEC2(point)); glhckFrustum *frustum = glhckCameraGetFrustum(object); kmVec3 nu, nv, fu, fv; kmVec3Subtract(&nu, &frustum->corners[GLHCK_FRUSTUM_CORNER_NEAR_BOTTOM_RIGHT], &frustum->corners[GLHCK_FRUSTUM_CORNER_NEAR_BOTTOM_LEFT]); kmVec3Subtract(&nv, &frustum->corners[GLHCK_FRUSTUM_CORNER_NEAR_TOP_LEFT], &frustum->corners[GLHCK_FRUSTUM_CORNER_NEAR_BOTTOM_LEFT]); kmVec3Subtract(&fu, &frustum->corners[GLHCK_FRUSTUM_CORNER_FAR_BOTTOM_RIGHT], &frustum->corners[GLHCK_FRUSTUM_CORNER_FAR_BOTTOM_LEFT]); kmVec3Subtract(&fv, &frustum->corners[GLHCK_FRUSTUM_CORNER_FAR_TOP_LEFT], &frustum->corners[GLHCK_FRUSTUM_CORNER_FAR_BOTTOM_LEFT]); kmVec3Scale(&nu, &nu, point->x); kmVec3Scale(&nv, &nv, point->y); kmVec3Scale(&fu, &fu, point->x); kmVec3Scale(&fv, &fv, point->y); pOut->start = frustum->corners[GLHCK_FRUSTUM_CORNER_NEAR_BOTTOM_LEFT]; pOut->dir = frustum->corners[GLHCK_FRUSTUM_CORNER_FAR_BOTTOM_LEFT]; kmVec3Add(&pOut->start, &pOut->start, &nu); kmVec3Add(&pOut->start, &pOut->start, &nv); kmVec3Add(&pOut->dir, &pOut->dir, &fu); kmVec3Add(&pOut->dir, &pOut->dir, &fv); kmVec3Subtract(&pOut->dir, &pOut->dir, &pOut->start); RET(2, "%p", pOut); return pOut; }
kmVec3* kmRay3IntersectPlane(kmVec3* pOut, const kmRay3* ray, const kmPlane* plane) { //t = - (A*org.x + B*org.y + C*org.z + D) / (A*dir.x + B*dir.y + C*dir.z ) double t = -(plane->a * ray->start.x + plane->b * ray->start.y + plane->c * ray->start.z + plane->d) / ( plane->a * ray->dir.x + plane->b * ray->dir.y + plane->c * ray->dir.z); kmVec3 scaled_dir; kmVec3Scale(&scaled_dir, &ray->dir, t); kmVec3Add(pOut, &ray->start, &scaled_dir); return pOut; }
void Mesh::enable_debug(bool value) { if(value) { if(normal_debug_mesh_) return; //This maintains a lock on the material MaterialID mid = resource_manager().new_material(); resource_manager().window->loader_for( "material_loader", Material::BuiltIns::DIFFUSE_ONLY )->into(resource_manager().material(mid)); normal_debug_mesh_ = new_submesh_with_material("__debug__", mid, MESH_ARRANGEMENT_LINES, VERTEX_SHARING_MODE_INDEPENDENT); //Go through the submeshes, and for each index draw a normal line each([=](const std::string& name, SubMesh* mesh) { for(uint16_t idx: mesh->index_data->all()) { Vec3 pos1 = mesh->vertex_data->position_at<Vec3>(idx); Vec3 n; mesh->vertex_data->normal_at(idx, n); kmVec3Scale(&n, &n, 10.0); kmVec3 pos2; kmVec3Add(&pos2, &pos1, &n); normal_debug_mesh_->vertex_data->position(pos1); normal_debug_mesh_->vertex_data->diffuse(smlt::Colour::RED); int16_t next_index = normal_debug_mesh_->vertex_data->move_next(); normal_debug_mesh_->index_data->index(next_index - 1); normal_debug_mesh_->vertex_data->position(pos2); normal_debug_mesh_->vertex_data->diffuse(smlt::Colour::RED); next_index = normal_debug_mesh_->vertex_data->move_next(); normal_debug_mesh_->index_data->index(next_index - 1); } }); normal_debug_mesh_->vertex_data->done(); normal_debug_mesh_->index_data->done(); } else { if(normal_debug_mesh_) { delete_submesh(normal_debug_mesh_->name()); normal_debug_mesh_ = nullptr; } } }
kmVec3* kmAABB3Centre(const kmAABB3* aabb, kmVec3* pOut) { kmVec3Add(pOut, &aabb->min, &aabb->max); kmVec3Scale(pOut, pOut, 0.5); return pOut; }
kglt::Vec3 operator/(float lhs, const kglt::Vec3& rhs) { kglt::Vec3 result; kmVec3Scale(&result, &rhs, 1.0 / lhs); return result; }
void GLAnimationCanvas::OnMouse(wxMouseEvent& event) { if (m_iType == TYPE_CURVE) { wxPoint wxpt = event.GetPosition(); Spline::Point pt(wxpt.x, wxpt.y); if (event.ButtonDown(wxMOUSE_BTN_LEFT)) { size_t index; if(m_spline->findKont(pt, index)) { m_selectedIndex = index; } else { m_selectedIndex = -1; } } else if(event.ButtonDown(wxMOUSE_BTN_RIGHT)) { size_t index; if(m_spline->findKont(pt, index)) { m_spline->removeKnot(index); m_selectedIndex = -1; } else { m_selectedIndex = m_spline->addKnots(pt); } } else if (event.Dragging()) { if(m_selectedIndex >= 0) { m_spline->setKnot(m_selectedIndex, pt); } } } else if (m_iType == TYPE_ANIMATION) { if(event.ButtonDown(wxMOUSE_BTN_RIGHT)) { ShowCursor(false); SetFocus(); if (!HasCapture()) { CaptureMouse(); } m_bRightDown = true; } else if(event.ButtonUp(wxMOUSE_BTN_RIGHT)) { ShowCursor(true); if (HasCapture()) { ReleaseMouse(); } ResetKeyStates(); m_bRightDown = false; } else if(event.ButtonDown(wxMOUSE_BTN_LEFT)) { ShowCursor(false); SetFocus(); if (!HasCapture()) { CaptureMouse(); } m_bLeftDown = true; } else if(event.ButtonUp(wxMOUSE_BTN_LEFT)) { ShowCursor(true); if (!HasCapture()) { CaptureMouse(); } ResetKeyStates(); m_bLeftDown = false; } else if(event.Dragging()) { wxPoint curPos = event.GetPosition(); wxPoint pnt = ClientToScreen(curPos); SetCursorPos(pnt.x, pnt.y); CRenderManager* pRenderMgr = CRenderManager::GetInstance(); if (m_bRightDown) { int nDeltaX = curPos.x - m_lastPosition.x; int nDeltaY = curPos.y - m_lastPosition.y; wxSize clientSize = GetClientSize(); pRenderMgr->GetCamera()->Yaw((float)nDeltaX / clientSize.x); pRenderMgr->GetCamera()->Pitch((float)nDeltaY / clientSize.y); } } else if(event.GetWheelAxis() == wxMOUSE_WHEEL_VERTICAL) { kmVec3 vec3Speed; kmVec3Fill(&vec3Speed, SHIFTWHEELSPEED, SHIFTWHEELSPEED, SHIFTWHEELSPEED); if (event.GetWheelRotation() > 0) { CRenderManager::GetInstance()->GetCamera()->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT)); } else if (event.GetWheelRotation() < 0) { kmVec3Scale(&vec3Speed, &vec3Speed, -1.0f); CRenderManager::GetInstance()->GetCamera()->Update(vec3Speed, (1 << CCamera::eCMT_STRAIGHT)); } } m_lastPosition = event.GetPosition(); } }
int process_inputs() { // Get mouse position double xpos, ypos; glfwGetCursorPos(mainWindow, &xpos, &ypos); // Reset mouse position for next frame glfwSetCursorPos(mainWindow, SCREEN_WIDTH/2, SCREEN_HEIGHT/2); // Compute new orientation horizontalAngle += mouseSpeed * (float)( SCREEN_WIDTH/2 - xpos ); verticalAngle += mouseSpeed * (float)( SCREEN_HEIGHT/2 - ypos ); /* If F1, reload */ if (glfwGetKey(mainWindow, GLFW_KEY_F1)) { Engine_Reload(); } /* If F2, reset view */ if (glfwGetKey(mainWindow, GLFW_KEY_F2)) { printf("Camera reset.\n"); Camera_Reset(); } /* If tab, change lookat to next mesh */ if (glfwGetKey(mainWindow, GLFW_KEY_TAB)) { //Camera_LookAtNext(); } /* Move closer */ //if (glfwGetKey(mainWindow, GLFW_KEY_W)) { // ypos = 100; //} /* Move further */ //if (glfwGetKey(mainWindow, GLFW_KEY_S)) { // ypos = -100; //} /* Move left */ //if (glfwGetKey(mainWindow, GLFW_KEY_A)) { // xpos = 100; //} /* Move right */ //if (glfwGetKey(mainWindow, GLFW_KEY_D)) { // xpos = -100; //} // Compute new orientation //horizontalAngle += mouseSpeed * (float)(1024/2 - xpos ); //verticalAngle += mouseSpeed * (float)( 768/2 - ypos ); horizontalAngle += mouseSpeed * xpos; verticalAngle += mouseSpeed * ypos; //printf("horizontalAngle is %f, and verticalAngle is %f.\n", horizontalAngle, verticalAngle); // Direction : Spherical coordinates to Cartesian coordinates conversion float temp1 = cos(verticalAngle) * sin(horizontalAngle); float temp2 = sin(verticalAngle); float temp3 = cos(verticalAngle) * cos(horizontalAngle); kmVec3 direction = {temp1, temp2, temp3}; // Right vector kmVec3 right = { sin(horizontalAngle - 3.14f/2.0f), 0, cos(horizontalAngle - 3.14f/2.0f) }; // Up vector kmVec3 up = *kmVec3Cross(&up, &right, &direction ); // Move forward if (glfwGetKey( mainWindow, GLFW_KEY_UP ) == GLFW_PRESS){ kmVec3Add(&position, &position, kmVec3Scale(&position, &direction, deltaTime * speed)); } // Move backward if (glfwGetKey( mainWindow, GLFW_KEY_DOWN ) == GLFW_PRESS){ kmVec3Subtract(&position, &position, kmVec3Scale(&position, &direction, deltaTime * speed)); } // Strafe right if (glfwGetKey( mainWindow, GLFW_KEY_RIGHT ) == GLFW_PRESS){ kmVec3Add(&position, &position, kmVec3Scale(&position, &right, deltaTime * speed)); } // Strafe left if (glfwGetKey( mainWindow, GLFW_KEY_LEFT ) == GLFW_PRESS){ kmVec3Subtract(&position, &position, kmVec3Scale(&position, &right, deltaTime * speed)); } float FoV = initialFoV; kmMat4PerspectiveProjection(&ProjectionMatrix, FoV, (16.0f / 8.0f), 0.1f, 100.0f); // Camera matrix //ViewMatrix = glm::lookAt( // position, // Camera is here // position+direction, // and looks here : at the same position, plus "direction" // up // Head is up (set to 0,-1,0 to look upside-down) // ); kmVec3 p_eye; p_eye = position; kmVec3 p_ctr; p_ctr = *kmVec3Add(&p_ctr, &position, &direction); kmVec3 p_up; p_up = up; kmMat4LookAt(&ViewMatrix, &p_eye, &p_ctr, &p_up); kmMat4Identity(&ModelMatrix); kmMat4 temp_mat; kmMat4Multiply(&temp_mat, &ViewMatrix, &ModelMatrix); kmMat4Multiply(&MVP, &ProjectionMatrix, &temp_mat ); //printf("Matrix contains:\n"); //printf("%f, %f, %f, %f\n", MVP.mat[0], MVP.mat[1], MVP.mat[2], MVP.mat[3]); //printf("%f, %f, %f, %f\n", MVP.mat[4], MVP.mat[5], MVP.mat[6], MVP.mat[7]); //printf("%f, %f, %f, %f\n", MVP.mat[8], MVP.mat[9], MVP.mat[10], MVP.mat[11]); //printf("%f, %f, %f, %f\n", MVP.mat[12], MVP.mat[13], MVP.mat[14], MVP.mat[15]); return 0; }
void CSkin::CalcSkelAnim(const CAnimationController::BoneMatrixMap &matrices) { CVertexPT *vertices = new CVertexPT[m_uVertexCount]; for(size_t i = 0; i < m_uVertexCount; ++i) { const CVertexPTB &vertex = m_vertices[i]; CVertexPT &vertex1 = vertices[i]; if(matrices.empty()) { vertex1.position = vertex.position; vertex1.tex = vertex.tex; continue; } kmVec3 pos; kmVec3Fill(&pos,vertex.position.x,vertex.position.y, vertex.position.z); kmVec3 finalpos; kmMat4 mat, mat2, mat3, mat4; if(vertex.bones.x >= 0) { auto itr = matrices.find(static_cast<ESkeletonBoneType>(vertex.bones.x)); BEATS_ASSERT(itr != matrices.end()); mat = itr->second; kmVec3 postmp; kmVec3Transform(&postmp,&pos,&mat); kmVec3Scale(&postmp, &postmp, vertex.weights.x); finalpos = postmp; } if(vertex.bones.y >= 0) { auto itr = matrices.find(static_cast<ESkeletonBoneType>(vertex.bones.y)); BEATS_ASSERT(itr != matrices.end()); mat2 = itr->second; kmVec3 postmp; kmVec3Transform(&postmp,&pos,&mat2); kmVec3Scale(&postmp, &postmp, vertex.weights.y); kmVec3Add(&finalpos,&finalpos,&postmp); } if(vertex.bones.z >= 0) { auto itr = matrices.find(static_cast<ESkeletonBoneType>(vertex.bones.z)); BEATS_ASSERT(itr != matrices.end()); mat3 = itr->second; kmVec3 postmp; kmVec3Transform(&postmp,&pos,&mat3); kmVec3Scale(&postmp, &postmp, vertex.weights.z); kmVec3Add(&finalpos,&finalpos,&postmp); } if(vertex.bones.w >= 0) { auto itr = matrices.find(static_cast<ESkeletonBoneType>(vertex.bones.w)); BEATS_ASSERT(itr != matrices.end()); mat4 = itr->second; kmVec3 postmp; kmVec3Transform(&postmp,&pos,&mat4); kmVec3Scale(&postmp, &postmp, vertex.weights.w); kmVec3Add(&finalpos,&finalpos,&postmp); } vertex1.position = finalpos; vertex1.tex = vertex.tex; } buildVBOVertex(vertices, m_uVertexCount*sizeof(CVertexPT)); BEATS_SAFE_DELETE_ARRAY(vertices); }
void Frustum::setupProjectionPerspective(const ViewTransform& view, float left, float right, float top, float bottom, float nearPlane, float farPlane) { kmVec3 cc = view.getPosition(); kmVec3 cDir = view.getDirection(); kmVec3 cRight = view.getRight(); kmVec3 cUp = view.getUp(); kmVec3Normalize(&cDir, &cDir); kmVec3Normalize(&cRight, &cRight); kmVec3Normalize(&cUp, &cUp); kmVec3 nearCenter; kmVec3 farCenter; kmVec3Scale(&nearCenter, &cDir, nearPlane); kmVec3Add(&nearCenter, &nearCenter, &cc); kmVec3Scale(&farCenter, &cDir, farPlane); kmVec3Add(&farCenter, &farCenter, &cc); //near { kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_NEAR], &nearCenter, &cDir); } //far { kmVec3 normal; kmVec3Scale(&normal, &cDir, -1); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_FAR], &farCenter, &normal); } //left { kmVec3 point; kmVec3Scale(&point, &cRight, left); kmVec3Add(&point, &point, &nearCenter); kmVec3 normal; kmVec3Subtract(&normal, &point, &cc); kmVec3Cross(&normal, &normal, &cUp); kmVec3Normalize(&normal, &normal); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_LEFT], &point, &normal); } //right { kmVec3 point; kmVec3Scale(&point, &cRight, right); kmVec3Add(&point, &point, &nearCenter); kmVec3 normal; kmVec3Subtract(&normal, &point, &cc); kmVec3Cross(&normal, &cUp, &normal); kmVec3Normalize(&normal, &normal); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_RIGHT], &point, &normal); } //bottom { kmVec3 point; kmVec3Scale(&point, &cUp, bottom); kmVec3Add(&point, &point, &nearCenter); kmVec3 normal; kmVec3Subtract(&normal, &point, &cc); kmVec3Cross(&normal, &cRight, &normal); kmVec3Normalize(&normal, &normal); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_BOTTOM], &point, &normal); } //top { kmVec3 point; kmVec3Scale(&point, &cUp, top); kmVec3Add(&point, &point, &nearCenter); kmVec3 normal; kmVec3Subtract(&normal, &point, &cc); kmVec3Cross(&normal, &normal, &cRight); kmVec3Normalize(&normal, &normal); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_TOP], &point, &normal); } }
void Frustum::setupProjectionOrthogonal(const cocos2d::ViewTransform &view, float width, float height, float nearPlane, float farPlane) { kmVec3 cc = view.getPosition(); kmVec3 cDir = view.getDirection(); kmVec3 cRight = view.getRight(); kmVec3 cUp = view.getUp(); kmVec3Normalize(&cDir, &cDir); kmVec3Normalize(&cRight, &cRight); kmVec3Normalize(&cUp, &cUp); //near { kmVec3 point; kmVec3 normal; normal = cDir; kmVec3Scale(&point, &cDir, nearPlane); kmVec3Add(&point, &point, &cc); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_NEAR], &point, &normal); } //far { kmVec3 point; kmVec3 normal; kmVec3Scale(&normal, &cDir, -1); kmVec3Scale(&point, &cDir, farPlane); kmVec3Add(&point, &point, &cc); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_FAR], &point, &normal); } //left { kmVec3 point; kmVec3 normal; normal = cRight; kmVec3Scale(&point, &cRight, -width * 0.5); kmVec3Add(&point, &point, &cc); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_LEFT], &point, &normal); } //right { kmVec3 point; kmVec3 normal; kmVec3Scale(&normal, &cRight, -1); kmVec3Scale(&point, &cRight, width * 0.5); kmVec3Add(&point, &point, &cc); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_RIGHT], &point, &normal); } //bottom { kmVec3 point; kmVec3 normal; normal = cUp; kmVec3Scale(&point, &cUp, -height * 0.5); kmVec3Add(&point, &point, &cc); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_BOTTOM], &point, &normal); } //top { kmVec3 point; kmVec3 normal; kmVec3Scale(&normal, &cUp, -1); kmVec3Scale(&point, &cUp, height * 0.5); kmVec3Add(&point, &point, &cc); kmPlaneFromPointAndNormal(&_frustumPlanes[FrustumPlane::FRUSTUM_TOP], &point, &normal); } }