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);
}
}
