コード例 #1
0
ファイル: d3d_display.cpp プロジェクト: AgentRev/ACE3
        void d3d_display::update_camera() {
            XMVECTOR DefaultForward, DefaultRight, camPosition;
            
            DefaultForward = XMLoadFloat4(&_camera.DefaultForward);
            DefaultRight = XMLoadFloat4(&_camera.DefaultRight);
            camPosition = XMLoadFloat4(&_camera.camPosition);

            XMMATRIX camRotationMatrix = XMMatrixRotationRollPitchYaw(_camera.camPitch, _camera.camYaw, 0);
            XMVECTOR camTarget = XMVector3TransformCoord(DefaultForward, camRotationMatrix);
            camTarget = XMVector3Normalize(camTarget);

            XMVECTOR camRight = XMVector3TransformCoord(DefaultRight, camRotationMatrix);
            XMVECTOR camForward = XMVector3TransformCoord(DefaultForward, camRotationMatrix);
            XMVECTOR camUp = XMVector3Cross(camForward, camRight);
           
            camPosition += _camera.moveLeftRight * camRight;
            camPosition += _camera.moveBackForward * camForward;
            XMStoreFloat4(&_camera.camPosition, camPosition);

            _camera.moveLeftRight = 0.0f;
            _camera.moveBackForward = 0.0f;

            camTarget = camPosition + camTarget;

            XMStoreFloat4x4(&_View, XMMatrixLookAtLH(camPosition, camTarget, camUp));
        }
コード例 #2
0
ファイル: LevelParts.cpp プロジェクト: kyllindros/Gawky3
void LevelParts::setWorld(XMFLOAT4X4 tempLevelPartsWorld)
{


	mLevelPartsWorld = tempLevelPartsWorld;


	XMMATRIX tempWorld = XMLoadFloat4x4(&mLevelPartsWorld);


	XMVECTOR Scale;
	XMVECTOR Position;
	XMVECTOR Rotation;


	XMMatrixDecompose(&Scale, &Rotation, &Position, tempWorld);

	XMStoreFloat3(&mLevelPartsPosition, Position);

	XMStoreFloat3(&mLevelPartsScale, Scale);

	XMStoreFloat4(&mLevelPartsRotation, Rotation);





	XMVECTOR S = XMLoadFloat3(&mLevelPartsScale);
	XMVECTOR P = XMLoadFloat3(&mLevelPartsPosition);
	XMVECTOR Q = XMLoadFloat4(&mLevelPartsRotationQuad);
	XMVECTOR rot = XMLoadFloat4(&mLevelPartsRotation);

	XMStoreFloat4x4(&mLevelPartsStartingWorld, XMMatrixAffineTransformation(S, rot, Q, P));

}
コード例 #3
0
ファイル: aasrenderer.cpp プロジェクト: pakoito/TemplePlus
void AasRenderer::RecalcNormals(int vertexCount, const XMFLOAT4* pos, XMFLOAT4* normals, int primCount, const uint16_t* indices) {
	static XMFLOAT4 recalcNormalsBuffer[0x8000];
	memset(recalcNormalsBuffer, 0, vertexCount * sizeof(XMFLOAT4));

	// Process every TRI we have
	auto curIdx = indices;
	for (auto tri = 0; tri < primCount; ++tri) {
		// Indices of the three vertices making up this triangle
		auto idx1 = *curIdx++;
		auto idx2 = *curIdx++;
		auto idx3 = *curIdx++;

		auto pos1 = XMLoadFloat4(&pos[idx1]);
		auto pos2 = XMLoadFloat4(&pos[idx2]);
		auto pos3 = XMLoadFloat4(&pos[idx3]);

		auto v1to2(pos2 - pos1);
		auto v1to3(pos3 - pos1);

		// Calculate the surface normal of the surface defined 
		// by the two directional vectors
		auto surfNormal(XMVector3Cross(v1to2, v1to3) * -1);

		// The surface normal contributes to all three vertex normals
		XMStoreFloat4(&normals[idx1], surfNormal);
		XMStoreFloat4(&normals[idx2], surfNormal);
		XMStoreFloat4(&normals[idx3], surfNormal);
	}

	// Re-Normalize the normals we calculated
	for (auto i = 0; i < vertexCount; ++i) {
		auto normal(XMVector3Normalize(XMLoadFloat4(&normals[i])));
		XMStoreFloat4(&normals[i], normal);
	}
}
コード例 #4
0
void Body::Update(float dt, btTransform& Parent)
{
	btVector3 parentPos;
	parentPos = Parent.getOrigin();

	//Get Offset Rotation of a model(child)
	btQuaternion LocalRot;
	LocalRot = btQuaternion(m_yaw, m_pitch, m_roll);

	btQuaternion parentRotation;
	parentRotation = Parent.getRotation();

	//Construct Directx Matricies out of give Quaternion rotations, sets up proper transformation of a model, Global + local
	XMMATRIX matrixChildRotation = XMMatrixRotationQuaternion(XMLoadFloat4(&XMFLOAT4(LocalRot.getX(), LocalRot.getY(), LocalRot.getZ(), LocalRot.getW())));
	XMMATRIX matrixParentRotation = XMMatrixRotationQuaternion(XMLoadFloat4(&XMFLOAT4(parentRotation.getX(), parentRotation.getY(), parentRotation.getZ(), parentRotation.getW())));

	//calcualte the final rotation by multiplying quaternions using dxmatrix
	XMMATRIX matrixFinalRotation = matrixChildRotation * matrixParentRotation;

	XMFLOAT3 m_offset = XMFLOAT3(0, 0, 0);
	XMMATRIX childOffset = XMMatrixTranslation(m_offset.x, m_offset.y, m_offset.z);

	XMMATRIX zeroWorld = XMMatrixTranslation(0, 0, 0);

	XMMATRIX translationMat = XMMatrixTranslation(parentPos.getX(), parentPos.getY(), parentPos.getZ());
	XMMATRIX scaleMat = XMMatrixScaling(m_scale, m_scale, m_scale);
	XMMATRIX worldMat = childOffset * matrixFinalRotation * zeroWorld * scaleMat * translationMat;

	XMStoreFloat4x4(&m_worldMat, worldMat);
}
コード例 #5
0
Enemy::Enemy() : mEnemyPosition(0.0f, 0.0f, 0.0f), mEnemyScale(3.0f, 3.0f, 3.0f), mEnemyRotation(0.0f, 0.0f, 0.0f, 1.0f),
mEnemyRotationQuad(0.0f, 0.0f, 0.0f, 0.0f), mEnemyPositionOne(0.0f, 0.0f, 0.0f), mEnemyPositionTwo(0.0f, 0.0f, 0.0f), travelToPoint(2), timesThrough(0)
{



	///initialize player
	XMVECTOR S = XMLoadFloat3(&mEnemyScale);
	XMVECTOR P = XMLoadFloat3(&mEnemyPosition);
	XMVECTOR Q = XMLoadFloat4(&mEnemyRotationQuad);
	XMVECTOR rot = XMLoadFloat4(&mEnemyRotation);
	XMStoreFloat4x4(&mEnemyWorld, XMMatrixAffineTransformation(S, rot, Q, P));


	currCharDirection = XMVectorSet(0.0f, 3.0f, 0.0f, 0.0f);
	oldCharDirection = XMVectorSet(0.0f, 3.0f, 0.0f, 0.0f);
	charPosition = XMVectorSet(0.0f, 3.0f, 0.0f, 0.0f);
	EnemyForward = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
	EnemyRight = XMVectorSet(1.0f, 0.0f, 0.0f, 0.0f);


	direction = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);
	lastPoint = mEnemyPositionOne;

}
コード例 #6
0
// Update frame-based values.
void D3D12Multithreading::OnUpdate()
{
	m_timer.Tick(NULL);

	PIXSetMarker(m_commandQueue.Get(), 0, L"Getting last completed fence.");

	// Get current GPU progress against submitted workload. Resources still scheduled 
	// for GPU execution cannot be modified or else undefined behavior will result.
	const UINT64 lastCompletedFence = m_fence->GetCompletedValue();

	// Move to the next frame resource.
	m_currentFrameResourceIndex = (m_currentFrameResourceIndex + 1) % FrameCount;
	m_pCurrentFrameResource = m_frameResources[m_currentFrameResourceIndex];

	// Make sure that this frame resource isn't still in use by the GPU.
	// If it is, wait for it to complete.
	if (m_pCurrentFrameResource->m_fenceValue > lastCompletedFence)
	{
		HANDLE eventHandle = CreateEvent(nullptr, FALSE, FALSE, nullptr);
		if (eventHandle == nullptr)
		{
			ThrowIfFailed(HRESULT_FROM_WIN32(GetLastError()));
		}
		ThrowIfFailed(m_fence->SetEventOnCompletion(m_pCurrentFrameResource->m_fenceValue, eventHandle));
		WaitForSingleObject(eventHandle, INFINITE);
		CloseHandle(eventHandle);
	}

	m_cpuTimer.Tick(NULL);
	float frameTime = static_cast<float>(m_timer.GetElapsedSeconds());
	float frameChange = 2.0f * frameTime;

	if (m_keyboardInput.leftArrowPressed)
		m_camera.RotateYaw(-frameChange);
	if (m_keyboardInput.rightArrowPressed)
		m_camera.RotateYaw(frameChange);
	if (m_keyboardInput.upArrowPressed)
		m_camera.RotatePitch(frameChange);
	if (m_keyboardInput.downArrowPressed)
		m_camera.RotatePitch(-frameChange);

	if (m_keyboardInput.animate)
	{
		for (int i = 0; i < NumLights; i++)
		{
			float direction = frameChange * pow(-1.0f, i);
			XMStoreFloat4(&m_lights[i].position, XMVector4Transform(XMLoadFloat4(&m_lights[i].position), XMMatrixRotationY(direction)));

			XMVECTOR eye = XMLoadFloat4(&m_lights[i].position);
			XMVECTOR at = { 0.0f, 8.0f, 0.0f };
			XMStoreFloat4(&m_lights[i].direction, XMVector3Normalize(XMVectorSubtract(at, eye)));
			XMVECTOR up = { 0.0f, 1.0f, 0.0f };
			m_lightCameras[i].Set(eye, at, up);

			m_lightCameras[i].Get3DViewProjMatrices(&m_lights[i].view, &m_lights[i].projection, 90.0f, static_cast<float>(m_width), static_cast<float>(m_height));
		}
	}

	m_pCurrentFrameResource->WriteConstantBuffers(&m_viewport, &m_camera, m_lightCameras, m_lights);
}
コード例 #7
0
ファイル: AnimKeys.cpp プロジェクト: am11/ffcore
// static
void ff::QuaternionKey::InitTangents(QuaternionKey *pKeys, size_t nKeys, float tension)
{
	for (size_t i = 0; i < nKeys; i++)
	{
		QuaternionKey &keyCur       = pKeys[i];
		QuaternionKey &keyBefore    = pKeys[i ? i - 1 : nKeys - 1];
		QuaternionKey &keyNext      = pKeys[(i + 1) % nKeys];
		QuaternionKey &keyAfterNext = pKeys[(i + 2) % nKeys];

		XMVECTOR keyCurTangent;
		XMVECTOR keyNextTangent;
		XMVECTOR keyNextValue;

		XMQuaternionSquadSetup(
			&keyCurTangent,                       // A
			&keyNextTangent,                      // B
			&keyNextValue,                        // C
			XMLoadFloat4(&keyBefore._value),     // Q0
			XMLoadFloat4(&keyCur._value),        // Q1
			XMLoadFloat4(&keyNext._value),       // Q2
			XMLoadFloat4(&keyAfterNext._value)); // Q3

		XMStoreFloat4(&keyCur._tangent,  keyCurTangent);
		XMStoreFloat4(&keyNext._tangent, keyNextTangent);
		XMStoreFloat4(&keyNext._value,   keyNextValue);
	}
}
コード例 #8
0
void AnimModel::CreateFinalMatrices(UINT clipNumber1, UINT frameNumber1, UINT clipNumber2, UINT frameNumber2, float blendFactor, XMFLOAT4X4* finalMatrices) { // смешивание двух клипов

	XMFLOAT3 positionF3;
	XMVECTOR quatF4;

	std::vector<XMFLOAT4X4> toRoot(bonesAmount);
	for (UINT i(0); i < bonesAmount; i++) {

		// загрузка матриц
		XMVECTOR position1 = XMLoadFloat3(&clips[clipNumber1].bonesPositions[i + bonesAmount * frameNumber1]);
		XMVECTOR position2 = XMLoadFloat3(&clips[clipNumber2].bonesPositions[i + bonesAmount * frameNumber2]);
		XMStoreFloat3(&positionF3, XMVectorLerp(position1, position2, blendFactor));
		XMVECTOR quaternion1 = XMLoadFloat4(&clips[clipNumber1].bonesQuaternions[i + bonesAmount * frameNumber1]);
		XMVECTOR quaternion2 = XMLoadFloat4(&clips[clipNumber2].bonesQuaternions[i + bonesAmount * frameNumber2]);
		quatF4 = XMQuaternionSlerp(quaternion1, quaternion2, blendFactor);

		// интерполяция матриц
		XMMATRIX T = XMMatrixTranslation(positionF3.x, positionF3.y, positionF3.z);
		XMMATRIX R = XMMatrixRotationQuaternion(quatF4);
		XMStoreFloat4x4(&toRoot[i], R * T);
	}

	// перемножение матриц для получения final
	for (UINT i(0); i < bonesAmount; i++) {
		UINT coef = order[i];
		if (hierarchy[coef] == -1) continue;
		XMStoreFloat4x4(&toRoot[coef], XMLoadFloat4x4(&toRoot[coef]) * XMLoadFloat4x4(&toRoot[hierarchy[coef]]));
	}
	for (UINT i(0); i < bonesAmount; i++) {
		XMMATRIX offSet = XMLoadFloat4x4(&offsetMatrices[i]);
		XMStoreFloat4x4(&finalMatrices[i], offSet * XMLoadFloat4x4(&toRoot[i]));
	}

}
コード例 #9
0
DirectX::XMFLOAT4 BoneAnimationData::GetRotationValue(float time)
{
	if(time <= rotationKeys[0].time)
		return rotationKeys[0].val;

	if(time >= rotationKeys[numberOfRotationKeys-1].time)
		return rotationKeys[numberOfRotationKeys-1].val;

	int rIndex;
	for(int i = 0;i < numberOfRotationKeys;i++)
	{
		if(rotationKeys[i].time >= time)
		{
			rIndex = i;
			break;
		}
	}

	float coef = (time - rotationKeys[rIndex-1].time) / (rotationKeys[rIndex].time - rotationKeys[rIndex-1].time);
	DirectX::XMVECTOR v1 = XMLoadFloat4(&rotationKeys[rIndex-1].val);
	DirectX::XMVECTOR v2 = XMLoadFloat4(&rotationKeys[rIndex].val);
	DirectX::XMVECTOR res = DirectX::XMQuaternionNormalize(DirectX::XMQuaternionSlerp(v1,v2,coef));
	DirectX::XMFLOAT4 r;
	DirectX::XMStoreFloat4(&r,res);

	return r;
}
コード例 #10
0
ファイル: BoidManager.cpp プロジェクト: hxshly/FYP
XMVECTOR BoidManager::getVectorBetween(birds &a, birds &b)
{
	XMVECTOR tempVectorA, tempVectorB, vectorBetween;

	tempVectorA = XMLoadFloat4(&a.getPosition());
	tempVectorB = XMLoadFloat4(&b.getPosition());
	vectorBetween = XMVectorSubtract(tempVectorA, tempVectorB);

	return vectorBetween;
}
コード例 #11
0
LightComponent::LightComponent(XMFLOAT4 pos, Light::LIGHTTYPE type, XMFLOAT4 dir, bool isCastingShadow, XMFLOAT4 color, float range, float spotAngle, float attenuation) :
m_range(range),
m_isCastingShadow(isCastingShadow)
{
	m_light.Position = XMLoadFloat4(&pos);
	m_light.Color = XMLoadFloat4(&color);
	m_light.Direction = XMLoadFloat4(&dir);
	XMFLOAT4 misc = XMFLOAT4(spotAngle, attenuation, (float)type, 0.0f);
	m_light.X_SpotAngleAndY_AttenuationAndZ_LightType = XMLoadFloat4(&misc);

}
コード例 #12
0
ファイル: graphics.cpp プロジェクト: zeo4/kolko_krzyzyk
void Graphics::exe_cam_curr(uint32_t const _i_zad) {
	XMStoreFloat4x4(&cam.mtx_view, XMMatrixLookAtLH(
		XMLoadFloat3(&cam.pos),
		XMVector3Rotate(XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f), XMLoadFloat4(&cam.quat)) + XMLoadFloat3(&cam.pos),
		XMVector3Rotate(XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f), XMLoadFloat4(&cam.quat))
	));
	XMStoreFloat4x4(&cam.mtx_proj, XMMatrixPerspectiveFovLH(
		cam.angle * 3.14f/180, float(szerRend)/wysRend, cam.near_z, cam.far_z
	));
	task.erase(_i_zad);
}
コード例 #13
0
ファイル: Camera.cpp プロジェクト: s0n4m/PhotonMapping
void Camera::rotateZ(float amount)
{
	XMMATRIX mRotate = XMMatrixRotationZ(amount);
	
	XMVECTOR new_x = XMVector4Transform(XMLoadFloat4(&v_Right), mRotate);
	XMVECTOR new_z = XMVector4Transform(XMLoadFloat4(&v_Look), mRotate);
	
	XMStoreFloat4(&v_Right, new_x);
	XMStoreFloat4(&v_Look, new_z);

	update();
}
コード例 #14
0
void Camera::CalculateViewProjection()
{
	// Initialize the view matrix
	XMVECTOR Eye = XMLoadFloat4(&_eye);
	XMVECTOR At = XMLoadFloat4(&_at);
	XMVECTOR Up = XMLoadFloat4(&_up);

	XMStoreFloat4x4(&_view, XMMatrixLookAtLH(Eye, At, Up));

	// Initialize the projection matrix
	XMStoreFloat4x4(&_projection, XMMatrixPerspectiveFovLH(XM_PIDIV2, _windowWidth / _windowHeight, _nearDepth, _farDepth));
}
コード例 #15
0
ファイル: Camera.cpp プロジェクト: s0n4m/PhotonMapping
void Camera::rotateX(float amount)
{
	XMMATRIX mRotate = XMMatrixRotationAxis(XMLoadFloat4(&v_Right), amount);
	
	XMVECTOR new_y = XMVector4Transform(XMLoadFloat4(&v_Up), mRotate);
	XMVECTOR new_z = XMVector4Transform(XMLoadFloat4(&v_Look), mRotate);
	
	XMStoreFloat4(&v_Up, new_y);
	XMStoreFloat4(&v_Look, new_z);

	update();
}
コード例 #16
0
bool FrustumClass::CheckPoint(float x, float y, float z)
{
	for (int i = 0; i < 6; i++)
	{
		XMVECTOR vector = XMPlaneDotCoord(XMLoadFloat4(&m_planes[i]), XMLoadFloat4(&XMFLOAT4(x, y, z, 1.0f)));

		if (vector.m128_f32[0] < 0.0f)
		{
			return false;
		}
	}
	return true;
}
コード例 #17
0
ファイル: Frustum.cpp プロジェクト: stwe/sgDx11
bool Frustum::CheckSphere(FLOAT xCenter, FLOAT yCenter, FLOAT zCenter, FLOAT radius)
{
     // Check if the radius of the sphere is inside the view frustum.
     for (INT i = 0; i < 6; i++)
     {
          if (XMPlaneDotCoord(XMLoadFloat4(&m_planes[i]), XMLoadFloat4(&XMFLOAT4(xCenter, yCenter, zCenter, 1.0f))).vector4_f32[0] < -radius)
          {
               return false;
          }
     }

     return true;
}
コード例 #18
0
ファイル: TestTriangleStripsDX.cpp プロジェクト: gpanic/3dApi
void TestTriangleStripsDX::Update()
{
	if (processInput)
	{
		float rotAmount = 0.0f;
		XMMATRIX rotMatrix = XMMatrixIdentity();
		if (input.right || input.left)
		{
			if (input.right)
				rotAmount = rotDelta;
			if (input.left)
				rotAmount = -rotDelta;
			rotMatrix = XMMatrixRotationAxis(XMLoadFloat4(&up), XMConvertToRadians(rotAmount));
		}
		else if (input.up || input.down)
		{
			if (input.up)
				rotAmount = rotDelta;
			if (input.down)
				rotAmount = -rotDelta;
			rotMatrix = XMMatrixRotationAxis(XMLoadFloat4(&right), XMConvertToRadians(rotAmount));
		}

		XMStoreFloat4(&eye, XMVector3Transform(XMLoadFloat4(&eye), rotMatrix));
		XMStoreFloat4(&right, XMVector3Normalize(XMVector3Cross(XMLoadFloat4(&up), (XMLoadFloat4(&center) - XMLoadFloat4(&eye)))));

		XMMATRIX viewMatrix = XMMatrixLookAtRH(XMLoadFloat4(&eye), XMLoadFloat4(&center), XMLoadFloat4(&up));
		mDeviceContext->UpdateSubresource(viewMatrixBuffer, 0, NULL, &viewMatrix, 0, 0);
	}
}
コード例 #19
0
void BoneAnimation::Interpolate(float t, XMFLOAT4X4& M)const
{
	if( t <= Keyframes.front().TimePos )
	{
		XMVECTOR S = XMLoadFloat3(&Keyframes.front().Scale);
		XMVECTOR P = XMLoadFloat3(&Keyframes.front().Translation);
		XMVECTOR Q = XMLoadFloat4(&Keyframes.front().RotationQuat);

		XMVECTOR zero = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f);
		XMStoreFloat4x4(&M, XMMatrixAffineTransformation(S, zero, Q, P));
	}
	else if( t >= Keyframes.back().TimePos )
	{
		XMVECTOR S = XMLoadFloat3(&Keyframes.back().Scale);
		XMVECTOR P = XMLoadFloat3(&Keyframes.back().Translation);
		XMVECTOR Q = XMLoadFloat4(&Keyframes.back().RotationQuat);

		XMVECTOR zero = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f);
		XMStoreFloat4x4(&M, XMMatrixAffineTransformation(S, zero, Q, P));
	}
	else
	{
		for(UINT i = 0; i < Keyframes.size()-1; ++i)
		{
			if( t >= Keyframes[i].TimePos && t <= Keyframes[i+1].TimePos )
			{
				float lerpPercent = (t - Keyframes[i].TimePos) / (Keyframes[i+1].TimePos - Keyframes[i].TimePos);

				XMVECTOR s0 = XMLoadFloat3(&Keyframes[i].Scale);
				XMVECTOR s1 = XMLoadFloat3(&Keyframes[i+1].Scale);

				XMVECTOR p0 = XMLoadFloat3(&Keyframes[i].Translation);
				XMVECTOR p1 = XMLoadFloat3(&Keyframes[i+1].Translation);

				XMVECTOR q0 = XMLoadFloat4(&Keyframes[i].RotationQuat);
				XMVECTOR q1 = XMLoadFloat4(&Keyframes[i+1].RotationQuat);

				XMVECTOR S = XMVectorLerp(s0, s1, lerpPercent);
				XMVECTOR P = XMVectorLerp(p0, p1, lerpPercent);
				XMVECTOR Q = XMQuaternionSlerp(q0, q1, lerpPercent);

				XMVECTOR zero = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f);
				XMStoreFloat4x4(&M, XMMatrixAffineTransformation(S, zero, Q, P));

				break;
			}
		}
	}
}
コード例 #20
0
ファイル: Frustum.cpp プロジェクト: stwe/sgDx11
bool Frustum::CheckPoint(FLOAT x, FLOAT y, FLOAT z)
{
     // Check if the point is inside all six planes of the view frustum.
     for (INT i = 0; i < 6; i++)
     {
          XMVECTOR vector = XMPlaneDotCoord(XMLoadFloat4(&m_planes[i]), XMLoadFloat4(&XMFLOAT4(x, y, z, 1.0f)));

          if (vector.vector4_f32[0] < 0.0f)
          {
               return false;
          }
     }

     return true;
}
コード例 #21
0
ファイル: Renderer.cpp プロジェクト: rizandigp/Iteration12
void Renderer::CullLight( SpotLight* light, Transform* pTransform )
{
	if (m_Mesh)
	{
		XNA::OrientedBox objectBox;
		XNA::Frustum lightFrustum = light->GetFrustum();
		for( int i=0; i<m_Mesh->GetNumberOfSubmeshes(); i++ )
		{
			if (m_SubmeshRenderData[i].bVisible)
			{
				Submesh* submesh = m_Mesh->GetSubmesh( i );

				XMVECTOR extents = XMLoadFloat3( &submesh->GetGeometryChunk()->GetAABB()->Extents );
				XMVECTOR scale = XMLoadFloat3( &pTransform->GetScale().intoXMFLOAT3() );
				XMVECTOR offset = XMLoadFloat3( &submesh->GetGeometryChunk()->GetAABB()->Center )*scale;
				XMVECTOR position = XMVector3Rotate( offset, XMLoadFloat4(&pTransform->GetOrientation().intoXMFLOAT4()) );
				position += XMLoadFloat3( &pTransform->GetPosition().intoXMFLOAT3() );
				XMStoreFloat3( &objectBox.Center, position );
				XMStoreFloat3( &objectBox.Extents, extents*scale );
				objectBox.Orientation = pTransform->GetOrientation().intoXMFLOAT4();

				if( XNA::IntersectOrientedBoxFrustum( &objectBox, &lightFrustum ) > 0 )
					m_SubmeshRenderData[i].AffectingSpotLights.push_back( light );
			}
		}
	}
}
コード例 #22
0
ファイル: Renderer.cpp プロジェクト: rizandigp/Iteration12
void Renderer::Cull( XNA::Frustum* frustum, Transform* pTransform )
{
	if (m_Mesh)
	{
		XNA::OrientedBox objectBox;
		for( int i=0; i<m_Mesh->GetNumberOfSubmeshes(); i++ )
		{
			Submesh* submesh = m_Mesh->GetSubmesh( i );

			XMVECTOR extents = XMLoadFloat3( &submesh->GetGeometryChunk()->GetAABB()->Extents );
			XMVECTOR scale = XMLoadFloat3( &pTransform->GetScale().intoXMFLOAT3() );
			XMVECTOR offset = XMLoadFloat3( &submesh->GetGeometryChunk()->GetAABB()->Center )*scale;
			XMVECTOR position = XMVector3Rotate( offset, XMLoadFloat4(&pTransform->GetOrientation().intoXMFLOAT4()) );
			position += XMLoadFloat3( &pTransform->GetPosition().intoXMFLOAT3() );
			XMStoreFloat3( &objectBox.Center, position );
			XMStoreFloat3( &objectBox.Extents, extents*scale );
			objectBox.Orientation = pTransform->GetOrientation().intoXMFLOAT4();
	
			if( XNA::IntersectOrientedBoxFrustum( &objectBox, frustum ) > 0 )
				m_SubmeshRenderData[i].bVisible = true;
			else
				m_SubmeshRenderData[i].bVisible = false;
		}
	}
}
コード例 #23
0
ファイル: BoidManager.cpp プロジェクト: hxshly/FYP
XMVECTOR BoidManager::findSeek(birds &bird)
{
	birds tempBird = bird;
	XMVECTOR seek = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
	XMVECTOR tempVectorI;
	XMVECTOR tempVectorTB = XMLoadFloat4(&tempBird.getPosition());
	float distanceBetween;
	bool seeking = false;
	int count = 0;

	for (int i = 0; i < maxBirds; i++)
	{
		if (m_birds.at(i)->getID() != tempBird.getID())
		{
			distanceBetween = getDistanceBetween(getVectorBetween(*m_birds.at(i), tempBird));

			if (distanceBetween < 15.0f)
			{
				tempVectorI = m_birds.at(i)->getVector();
				seek = XMVectorAdd(seek, tempVectorI);
				++count;
			}
		}
	}
	
	if (count > 1)
	{
	seek = XMVectorSubtract(seek, tempVectorTB);
	seek = XMVector4Normalize(seek);
	seek = seek / (count - 1);
	seek = XMVectorSubtract(seek, tempBird.getVector()) / 100;
	}

	return seek;
}
コード例 #24
0
	void RenderString::Render(SpriteFont *spriteFontPtr, SpriteBatch *spriteBatchPtr)
	{
		spriteFontPtr->DrawString(spriteBatchPtr, text.c_str(), XMLoadFloat3(&position), 
			XMLoadFloat4(&color), rotation, XMLoadFloat3(&origin),	XMLoadFloat3(&scale), effects, 
			layerDepth);

	}
コード例 #25
0
_Use_decl_annotations_
void BspCompiler::SplitEdge(const Vertex& v0, const Vertex& v1, const XMFLOAT4& plane, Vertex* v)
{
    XMFLOAT3 vv0 = v0.Position;
    XMFLOAT3 vv1 = v1.Position;

    float d0 = DistToPlane(plane, vv0);

    XMVECTOR sub = XMVectorSubtract(XMLoadFloat3(&vv1), XMLoadFloat3(&vv0));
    XMVECTOR dir = XMVector3Normalize(sub);
    XMVECTOR n = XMLoadFloat4(&plane);
    float d = d0;
    if (d > 0)
    {
        n = XMVectorNegate(n);
    }
    else if (d < 0)
    {
        d = -d;
    }
    else
    {
        assert(false);
    }

    float x = d / XMVectorGetX(XMVector3Dot(n, dir));
    XMStoreFloat3(&v->Position, XMVectorAdd(XMLoadFloat3(&vv0), XMVectorScale(dir, x)));
}
コード例 #26
0
ファイル: Direct3D.cpp プロジェクト: Beight/MultiCore
void Direct3D::update(float dt)
{
	static float rotDT = 0.f;
	rotDT = dt;
	XMMATRIX rot = XMMatrixRotationAxis(XMVectorSet(0.f, 0.f, 1.f, 0.f), rotDT);
	for(int i = 0; i < NROFLIGHTS; i++)
	{
		XMVECTOR vLightPos = XMLoadFloat4(&m_lightList[i].pos);
		vLightPos = XMVector4Transform(vLightPos, rot);
		XMStoreFloat4(&m_lightList[i].pos, vLightPos);
	}
	m_pCamera->update();
	//m_fps = 1/dt;
	m_time += dt;
	static int frameCnt = 0;
    static float t_base = 0.f;
	frameCnt++;
	
	if(m_time - t_base >= 1.f)
	{
		frameCnt /= 1;
		m_fps = (float)frameCnt;
		frameCnt = 0;
		t_base += 1.f;
	}

	updateConstantBuffers();
}
コード例 #27
0
// создать финальные матрицы для шейдера
void AnimModel::CreateFinalMatricesOldStyle(UINT clipNumber, UINT frameNumber, XMFLOAT4X4* finalMatrices) { // без смешивания клипов по древнему алгоритму (для отладки)

	// загрузка матриц
	std::vector<XMFLOAT4X4> reserve(bonesAmount);
	std::vector<XMFLOAT4X4> reserve2(bonesAmount);
	for (UINT i(0); i < bonesAmount; i++) {
		XMFLOAT3 position = clips[clipNumber].bonesPositions[i + bonesAmount * frameNumber];
		XMMATRIX T = XMMatrixTranslation(position.x, position.y, position.z);
		XMFLOAT4 quaternion = clips[clipNumber].bonesQuaternions[i + bonesAmount * frameNumber];
		XMMATRIX R = XMMatrixRotationQuaternion(XMLoadFloat4(&quaternion));
		XMStoreFloat4x4(&reserve[i], R * T);
		XMStoreFloat4x4(&reserve2[i], R * T);
	}

	// перемножение матриц для получения final
	for (UINT i(0); i < bonesAmount; i++) {
		XMMATRIX fin = XMMatrixIdentity();
		UINT curMatrix = i;
		fin = fin * XMLoadFloat4x4(&reserve[curMatrix]);
		while (curMatrix != -1) {
			curMatrix = hierarchy[curMatrix];
			if (curMatrix == -1) break;
			fin = fin * XMLoadFloat4x4(&reserve[curMatrix]);
		}
		XMMATRIX offSet = XMLoadFloat4x4(&offsetMatrices[i]);
		XMStoreFloat4x4(&finalMatrices[i], offSet * fin);
	}

}
コード例 #28
0
ファイル: AnimKeys.cpp プロジェクト: am11/ffcore
// static
void ff::VectorKey::InitTangents(VectorKey *pKeys, size_t nKeys, float tension)
{
	tension = (1.0f - tension) / 2.0f;

	for (size_t i = 0; i < nKeys; i++)
	{
		const VectorKey &keyBefore = pKeys[i ? i - 1 : nKeys - 1];
		const VectorKey &keyAfter  = pKeys[i + 1 < nKeys ? i + 1 : 0];

		XMStoreFloat4(&pKeys[i]._tangent,
			XMVectorMultiply(
				XMVectorReplicate(tension),
				XMVectorSubtract(
					XMLoadFloat4(&keyAfter._value),
					XMLoadFloat4(&keyBefore._value))));
	}
}
コード例 #29
0
	void RayTraceDataGenerator::GenerateRaytraceResult(int width, int height,float scale, XMFLOAT4 loc, int neardistance, int maxdepth, XMFLOAT4 n, XMFLOAT4 up, void(*CallbackFunc)(int x, int y, const int& TexType, const XMFLOAT4& loc, const XMFLOAT4& n,const float& depth, void* arg), void* arg)
	{
		XMVECTOR v_ori = XMLoadFloat4(&loc);
		XMVECTOR v_center=XMLoadFloat4(&loc);
		XMVECTOR v_n = XMLoadFloat4(&n);
		XMVECTOR v_up = XMVector3Normalize(XMLoadFloat4(&up));
		v_center = XMVectorAdd(v_center, XMVectorScale(v_n, neardistance));
		XMVECTOR v_dir_x = XMVector3Cross(v_n, v_up);
		XMVECTOR v_dir_y = XMVector3Cross(v_n, v_dir_x);
		XMVECTOR v_current = XMVectorAdd(v_center, XMVectorScale(v_dir_x, -scale*width*0.5));
		XMVECTOR v_ret_n;
		XMVECTOR v_ret_loc;
		//XMFLOAT4 v_unpacked;
		XMFLOAT4 v_ret_unpack_n;
		XMFLOAT4 v_ret_unpack_loc;
		XMVECTOR v_corner1;
		XMVECTOR v_corner2;
		bool result;
		float f_ret_depth;
		v_current = XMVectorAdd(v_current, XMVectorScale(v_dir_y, -scale*height*0.5));
		v_corner1 = v_current;
		v_corner2 = XMVectorAdd(v_current, XMVectorScale(v_dir_y, +scale*height*1.0));
		v_corner2 = XMVectorAdd(v_corner2, XMVectorScale(v_dir_x, +scale*width*1.0));
		for (int i = 0; i < width; i++)
		{
			for (int j = 0; j < height; j++)
			{//XMVector3Normalize(XMVectorSubtract(v_current, v_ori))
				result = CalcIntersect(v_current, v_n, &v_ret_n, &v_ret_loc, &f_ret_depth);
				if (result)
				{
					XMStoreFloat4(&v_ret_unpack_loc,v_ret_loc);
					XMStoreFloat4(&v_ret_unpack_n, v_ret_n);
					CallbackFunc(i, j, GetLocInfo((int)v_ret_unpack_loc.x, (int)v_ret_unpack_loc.y, (int)v_ret_unpack_loc.z), v_ret_unpack_loc, v_ret_unpack_n, f_ret_depth, arg);
				}
				else
				{
					v_ret_unpack_n.x = v_ret_unpack_n.y = v_ret_unpack_n.z = -1;
					v_ret_unpack_loc.x = v_ret_unpack_loc.y = v_ret_unpack_loc.z = -1;
					f_ret_depth = -1;
					CallbackFunc(i, j, -1, v_ret_unpack_loc, v_ret_unpack_n, f_ret_depth, arg);
				}
				v_current = XMVectorAdd(v_current, XMVectorScale(v_dir_y, scale));
			}
			v_current = XMVectorAdd(v_current, XMVectorScale(v_dir_x, scale));
		}
	}
コード例 #30
0
XMFLOAT3 EliteEnemyShip::getPosition()
{
	XMFLOAT4 pos;
	XMFLOAT4 orig = XMFLOAT4(0,0,0,1);
	XMFLOAT4X4 mat = *(body->getWorldMatrix());
	XMStoreFloat4(&pos, XMVector4Transform(XMLoadFloat4(&orig), XMLoadFloat4x4(&mat)));
	return (XMFLOAT3(pos.x, pos.y, pos.z));
}