Ejemplo n.º 1
0
void LookAt::LateUpdate() {
	Transform* looker_transform = GetGameObject()->GetTransform();
	Transform* target_transform = nullptr;

	// Finds the target based on its instance id each update 
	// to avoid having a dangling pointer
	// to an object that might have been destroyed.
	target = GameObject::GetGameObjectInstance(targetId);

	// TODO - comment this out and write your own solution
	target_transform = target->GetTransform();

	Float4x4 lookerMatrix = looker_transform->GetLocalMatrix();
	Float4x4 targetMatrix = target_transform->GetLocalMatrix();

	Float3 lookerPos = Float3(lookerMatrix.WAxis);
	Float3 targetPos = Float3(targetMatrix.WAxis);
	Float3 xAxis = ZERO_VECTOR;
	Float3 yAxis = ZERO_VECTOR;
	Float3 zAxis = (targetPos - lookerPos).normalize();
	CrossProduct(xAxis, zAxis, Float3(0.0f, 1.0f, 0.0f));
	xAxis.normalize();

	CrossProduct(yAxis, zAxis, xAxis);
	yAxis.normalize();

	Float4x4 localMatrix = Float4x4(
		xAxis.x, xAxis.y, xAxis.z, lookerMatrix.padX,
		yAxis.x, yAxis.y, yAxis.z, lookerMatrix.padY,
		zAxis.x, zAxis.y, zAxis.z, lookerMatrix.padZ,
		lookerMatrix.WAxis.x, lookerMatrix.WAxis.y, lookerMatrix.WAxis.z, lookerMatrix.padW
	);
	looker_transform->SetLocalMatrix(localMatrix);
	//LookAtSolution();
}
Ejemplo n.º 2
0
	void SpotLight::ApplyLight()
	{
		// Set spot light position and direction
		Float3 dir3(GetWorldMatrixPtr()->_31, GetWorldMatrixPtr()->_32, GetWorldMatrixPtr()->_33);
		dir3.normalize();

		XMFLOAT3 pos(&GetWorldMatrixPtr()->_41);

		cBufferData.spotLight.direction = XMFLOAT3(dir3.x, dir3.y, dir3.z);
		cBufferData.spotLight.position = pos;

		D3D11_MAPPED_SUBRESOURCE edit;
		Renderer::theContextPtr->Map(cBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &edit);
		memcpy(edit.pData, &cBufferData, sizeof(cBufferData));
		Renderer::theContextPtr->Unmap(cBuffer, 0);

		Renderer::theContextPtr->VSSetConstantBuffers(cBufferData.SPOT_LIGHT_REGISTER_SLOT, 1, &cBuffer.p);
		Renderer::theContextPtr->PSSetConstantBuffers(cBufferData.SPOT_LIGHT_REGISTER_SLOT, 1, &cBuffer.p);


		// Check if the camera is inside the lit area
		Float3 toCamera = ViewPortManager::GetReference().GetActiveViewPosition() 
			- *(Float3 *)&pos.x;
		toCamera.normalize();

		if(toCamera.dotProduct(dir3) > cBufferData.spotLight.cutoff)
			techniqueNameOverride = "RenderSpotLightInside";
		else
			techniqueNameOverride = "RenderSpotLightOutside";
		AddToContextSet();
	}
Ejemplo n.º 3
0
	void Physics::OnUpdate(IBehavior* invokingBehavior, IMessage* message)
	{
		Physics* pPhysics = (Physics*)invokingBehavior;

		const Aabb& objLocalAabb = pPhysics->gameObject->GetLocalAabb();
		for(unsigned int i = 0; i < 3; ++i)
		{
			if( pPhysics->localAabb.min.v[i] != objLocalAabb.min.v[i] ||
				pPhysics->localAabb.max.v[i] != objLocalAabb.max.v[i] )
			{
				pPhysics->Initialize();
				return;
			}
		}

		if( pPhysics->physicsFlags & GRAVITY )
		{
			Attribute<bool>* groundedAttrib = (Attribute<bool>*)pPhysics->GetAttribute(
				PhysicsAttributes::GROUNDED_ATTRIB);

			if( groundedAttrib->value == false )
				pPhysics->ApplyGravity();
		}

		Float3 com(0.0f, 0.0f, 0.0f);
		for(unsigned int i = 0; i < pPhysics->m_X.size(); ++i)
			com += pPhysics->m_X[i];
		
		com *= (1.0f / pPhysics->m_X.size());

		pPhysics->ApplyVerlet();
		pPhysics->ApplyConstraints();

		Float3 newcom(0.0f, 0.0f, 0.0f);
		for(unsigned int i = 0; i < pPhysics->m_X.size(); ++i)
			newcom += pPhysics->m_X[i];
		
		newcom *= (1.0f / pPhysics->m_X.size());

		Float3 delta = newcom - com;

		if( delta.magnitude() > 0.25f )
		{
			delta.normalize();
			delta *= 0.25f;
		}

		pPhysics->gameObject->TranslateGlobal( delta );
	}
Ejemplo n.º 4
0
void RenderController::SetPerCameraShaderVariables() {
	ViewPortManager &vpm = ViewPortManager::GetReference();

	XMVECTOR det;

	cbPerCamera camBuffer;

	camBuffer.gViewProj = *(XMFLOAT4X4 *)&ViewPortManager::GetReference().GetActiveViewProjection();
	camBuffer.gCameraPos = XMFLOAT3(vpm.GetActiveViewPosition().v);
	Float3 camDir = vpm.GetActiveViewForward();
	camDir.normalize();
	camBuffer.gCameraDir = XMFLOAT3(camDir.v);

	camBuffer.gFarDist = vpm.GetActiveViewFarClip();
	//camBuffer.gNearDist = vpm.GetActiveViewNearClip();
	float nearDist = vpm.GetActiveViewNearClip();

	camBuffer.gScreenSize.x = (float)Renderer::GetResolutionWidth();
	camBuffer.gScreenSize.y = (float)Renderer::GetResolutionHeight();

	XMStoreFloat4x4(&camBuffer.gInvViewProj, XMMatrixInverse(&det, XMLoadFloat4x4(&camBuffer.gViewProj)));

	camBuffer.gPlaneX = -camBuffer.gFarDist / (camBuffer.gFarDist - nearDist);
	camBuffer.gPlaneY = -camBuffer.gFarDist * nearDist /
		(camBuffer.gFarDist - nearDist);

	D3D11_MAPPED_SUBRESOURCE edit;
	Renderer::theContextPtr->Map(cameraCBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &edit);
	memcpy(edit.pData, &camBuffer, sizeof(camBuffer));
	Renderer::theContextPtr->Unmap(cameraCBuffer, 0);

	Renderer::theContextPtr->VSSetConstantBuffers(camBuffer.REGISTER_SLOT, 1, &cameraCBuffer.p);
	Renderer::theContextPtr->PSSetConstantBuffers(camBuffer.REGISTER_SLOT, 1, &cameraCBuffer.p);
	Renderer::theContextPtr->GSSetConstantBuffers(camBuffer.REGISTER_SLOT, 1, &cameraCBuffer.p);
	Renderer::theContextPtr->HSSetConstantBuffers(camBuffer.REGISTER_SLOT, 1, &cameraCBuffer.p);
	Renderer::theContextPtr->DSSetConstantBuffers(camBuffer.REGISTER_SLOT, 1, &cameraCBuffer.p);
}
Ejemplo n.º 5
0
void renderFrame(float dt) {
  if (rotate_light) {
    renderer::LightDir* light = render->light_dir();
    Float3* dir = light->direction_world();
    Float4x4::rotateMatYAxis(mat_tmp, dt);
    Float3 new_dir;
    Float3::affineTransformVec(new_dir, mat_tmp, *dir);
    dir->set(new_dir);
  }

  // Move the camera
  delta_pos.set(cur_dir);
  const Float3 zeros(0, 0, 0);
  if (!Float3::equal(delta_pos, zeros)) {
    delta_pos.normalize();
    Float3::scale(delta_pos, camera_speed * dt);
    if (running) {
      Float3::scale(delta_pos, camera_run_mulitiplier);
    }
    render->camera()->moveCamera(&delta_pos);
  }

  float* cur_coeff;
  if (fit_right && fit_left) {
    cur_coeff = l_hand_coeffs[cur_image]->coeff();
    models[0]->updateMatrices(l_hand_coeffs[cur_image]->coeff());
    models[1]->updateMatrices(r_hand_coeffs[cur_image]->coeff());
  }
  if (fit_right) {
    cur_coeff = r_hand_coeffs[cur_image]->coeff();
    models[0]->updateMatrices(r_hand_coeffs[cur_image]->coeff());
  } else if (fit_left) {
    cur_coeff = l_hand_coeffs[cur_image]->coeff();
    models[0]->updateMatrices(l_hand_coeffs[cur_image]->coeff());
  }
  HandGeometryMesh::setCurrentStaticHandProperties(cur_coeff);

  // Now render the final frame
  Float4x4 identity;
  identity.identity();
  switch (render_output) {
  case 1:
    render->renderFrame(dt);
    if (render_depth) {
      for (uint32_t k = 0; k < std::min<uint32_t>(MAX_KINECTS, 
        num_point_clouds_to_render); k++) {
        render->renderColoredPointCloud(geometry_points[k], 
          &camera_view[k], 
          point_cloud_scale * 1.5f * static_cast<float>(settings.width) / 4.0f);
      }
    }
    break;
  case 2:
    float coeff[num_models * num_coeff_fit];
    if (fit_left && !fit_right) {
      memcpy(coeff, l_hand_coeffs[cur_image]->coeff(), sizeof(coeff[0])*num_coeff_fit);
    } else if (!fit_left && fit_right) {
      memcpy(coeff, r_hand_coeffs[cur_image]->coeff(), sizeof(coeff[0])*num_coeff_fit);
    } else {
      memcpy(coeff, l_hand_coeffs[cur_image]->coeff(), sizeof(coeff[0])*num_coeff_fit);
      memcpy(&coeff[num_coeff_fit], r_hand_coeffs[cur_image]->coeff(), 
        sizeof(coeff[0])*num_coeff_fit);
    }

    fit->model_renderer()->drawDepthMap(coeff, num_coeff_fit, models,
      num_models, cur_kinect, false);
    fit->model_renderer()->visualizeDepthMap(wnd, cur_kinect);
    break;
  default:
    throw runtime_error("ERROR: render_output is an incorrect value");
  }
  wnd->swapBackBuffer();
}
Ejemplo n.º 6
0
void Renderer::updateFlashlight(float dt) {
    static float time = 0;
    bool on;
    GET_SETTING("flashlight_on", bool, on);
    flashlight_->on() = on;
    flashlight_model_->setRenderHierarchy(on);  // recursive
    if (on) {
        time += dt;
        float dist=10.0f, outer_fov=0.5f, inner_fov=0.4f,
              diffuse_intensity = 1.0f, scale = 1.0f;
        int csvm_count = 1;
        Float3 pos_view;
        Float3 target_view;
        GET_SETTING("flashlight_dist", float, dist);
        GET_SETTING("flashlight_outer_fov", float, outer_fov);
        GET_SETTING("flashlight_inner_fov", float, inner_fov);
        GET_SETTING("flashlight_csvm_count", int, csvm_count);
        GET_SETTING("flashlight_diffuse_intensity", float, diffuse_intensity);
        GET_SETTING("flashlight_pos_view", Float3, pos_view);
        GET_SETTING("flashlight_target_view", Float3, target_view);
        GET_SETTING("flashlight_scale", float, scale);
        flashlight_->near_far().set(0.1f, dist);
        flashlight_->outer_fov_deg() = outer_fov;
        flashlight_->diffuse_intensity() = diffuse_intensity;
        flashlight_->inner_fov_deg() =inner_fov;
        flashlight_->cvsm_count(csvm_count);

        // The light object itself...
        Float3::affineTransformPos(flashlight_->pos_world(), camera_->view_inv(),
                                   pos_view);

        // Add some noise to the world position
        Float3 rand_vec;
        rand_vec[0] = math::PerlinNoise::Noise(0.0f, 0.5f*time) * 0.15f;
        rand_vec[1] = math::PerlinNoise::Noise(100.0f, 0.5f*time) * 0.15f;
        rand_vec[2] = 0;
        Float3::add(flashlight_->pos_world(), rand_vec,
                    flashlight_->pos_world());

        Float3 dir_view;
        Float3::sub(dir_view, target_view, pos_view);
        dir_view.normalize();
        Float3::affineTransformVec(flashlight_->dir_world(), camera_->view_inv(),
                                   dir_view);
        rand_vec[0] = math::PerlinNoise::Noise(0.0f, 0.5f*time) * 0.15f;
        rand_vec[1] = math::PerlinNoise::Noise(100.0f, 0.5f*time) * 0.15f;
        rand_vec[2] = 0;
        Float3::add(flashlight_->dir_world(), rand_vec,
                    flashlight_->dir_world());

        // Now the flashlight model
        Float4x4& world_mat = flashlight_model_->mat();
        Float3 up(0, 1, 0);
        if (fabsf(fabsf(Float3::dot(flashlight_->dir_world(), up)) - 1) < EPSILON) {
            // preturb the up vector
            up[0] += (float)LOOSE_EPSILON;
            up[2] += (float)LOOSE_EPSILON;
            up.normalize();
        }
        Float3 side;
        Float3::cross(side, up, flashlight_->dir_world());
        side.normalize();
        Float3::cross(up, flashlight_->dir_world(), side);
        up.normalize();
        Float4x4::rotateMatBasis(world_mat, up, flashlight_->dir_world(), side);
        world_mat.rightMultScale(scale, scale, scale);
        world_mat.leftMultTranslation(flashlight_->pos_world());
    }
}
Ejemplo n.º 7
0
void Camera::Update(int width, int height, float delta)
{
	Float3 translation = ZERO_VECTOR;
	float deltaX = 0;
	float deltaY = 0;

	float moveFactor = m_fSpeed * delta;

	if (GetAsyncKeyState('W'))
		translation += Float3(0.0f, 0.0f, -moveFactor);
	// back
	if (GetAsyncKeyState('S'))
		translation += Float3(0.0f, 0.0f, moveFactor);
	// left
	if (GetAsyncKeyState('A'))
		translation += Float3(moveFactor, 0.0f, 0.0f);
	// right
	if (GetAsyncKeyState('D'))
		translation += Float3(-moveFactor, 0.0f, 0.0f);
	// up
	if (GetAsyncKeyState('E'))
		translation += Float3(0.0f, -moveFactor, 0.0f);
	// down
	if (GetAsyncKeyState('Q'))
		translation += Float3(0.0f, moveFactor, 0.0f);

	if (GetAsyncKeyState(VK_RBUTTON) & 0x8000)
	{
		GetCursorPos(&m_lpCurrentPosition);
		SetCursorPos((int)(width)* 0.65f, (int)(height)* 0.65f);
		GetCursorPos(&m_lpPreviousPosition);
		ShowCursor(false);
		deltaY = (float)(m_lpPreviousPosition.y - m_lpCurrentPosition.y);
		deltaX = (float)(m_lpPreviousPosition.x - m_lpCurrentPosition.x);
	}
	else
	{
		ShowCursor(true);
	}
	// deffered context 

	Float4x4 rotationX = IDENTITY;
	Float4x4 rotationY = IDENTITY;
	rotationX.makeRotationX((float)deltaY);
	rotationY.makeRotationY((float)deltaX);

	m_mView.translateLocal(translation.negate());
	m_mView.rotateLocalX((float)-deltaY * moveFactor * 0.1f);
	m_mView.rotateLocalY((float)-deltaX * moveFactor * 0.1f);

	Float3 forward = m_mView.ZAxis;
	Float3 up;
	Float3 right;

	forward.normalize();
	CrossProduct(right, Float3(0, 1, 0), forward);
	right.normalize();
	CrossProduct(up, forward, right);
	up.normalize();

	m_mView.XAxis = right;
	m_mView.YAxis = up;
	m_mView.ZAxis = forward;

	XMFLOAT4X4 tempMat = *((XMFLOAT4X4*)&m_mView);
	XMMATRIX tempInv = XMLoadFloat4x4(&tempMat);
	tempInv = XMMatrixInverse(NULL, tempInv);
	XMStoreFloat4x4((XMFLOAT4X4*)&m_mInvView, tempInv);

	//XMMATRIX tempView = XMLoadFloat4x4(&m_mView);
	///*tempTransform = XMMatrixMultiply(rotationX, tempTransform);
	//tempTransform = XMMatrixMultiply(rotationY, tempTransform);*/
	//XMMATRIX rotation = XMMatrixRotationRollPitchYaw((float)deltaY * delta * 0.5f, (float)deltaX * delta * 0.5f, 0);
	//tempTransform = XMMatrixMultiply(rotation, tempTransform);
	//tempView = XMMatrixMultiply(tempView, tempTransform);

	//XMStoreFloat4x4(&m_mView, tempView);

	//XMFLOAT3 tempForward = XMFLOAT3(m_mView._31, m_mView._32, m_mView._33);
	//XMFLOAT3 tempUp;
	//XMFLOAT3 tempRight;
	//XMFLOAT3 tempWorldUp = XMFLOAT3(0, 1, 0);

	//XMVECTOR worldUp = XMLoadFloat3(&tempWorldUp);
	//XMVECTOR forward = XMLoadFloat3(&tempForward);
	//forward = XMVector3Normalize(forward);
	//XMVECTOR right = XMVector3Cross(worldUp, forward);
	//right = XMVector3Normalize(right);
	//XMVECTOR up = XMVector3Cross(right, forward);
	//up = XMVector3Normalize(up);

	//XMStoreFloat3(&tempUp, up);
	//XMStoreFloat3(&tempForward, forward);
	//XMStoreFloat3(&tempRight, right);

	///*m_mView._11 = tempRight.x; m_mView._12 = tempRight.y; m_mView._13 = tempRight.z;
	//m_mView._21 = tempRight.x; m_mView._22 = tempRight.y; m_mView._23 = tempRight.z;
	//m_mView._31 = tempRight.x; m_mView._32 = tempRight.y; m_mView._33 = tempRight.z;*/


	//ConstructMV();
}