bounding sphere of a modal mesh about directxtk HOT 13 CLOSED

XMMATRIX modelWorld = ...;
BoundingSphere worldSphere;
m_bounding.Transform(worldSphere, modelWorld);

m_batch = std::make_unique<PrimitiveBatch<VertexPositionColor>>(context);
m_effect = std::make_unique<BasicEffect>(device);
m_effect->SetVertexColorEnabled(true);
{
    void const* shaderByteCode;
    size_t byteCodeLength;

    m_effect->GetVertexShaderBytecode(&shaderByteCode, &byteCodeLength);

    DX::ThrowIfFailed(
        device->CreateInputLayout(
            VertexPositionColor::InputElements, VertexPositionColor::InputElementCount,
           shaderByteCode, byteCodeLength,
            m_layout.ReleaseAndGetAddressOf()));
}

...

XMMATRIX modelWorld = ...;
XMMATRIX view = m_Camera.ViewMatrix();
XMMATRIX proj = m_Camera.ProjectionMatrix();
m_Tree->Draw( context, *m_states, modelWorld, view, proj);

#ifdef _DEBUG
// Draws an outline of the bounding volume over the model
context->OMSetBlendState(m_states->Opaque(), nullptr, 0xFFFFFFFF);
context->OMSetDepthStencilState(m_states->DepthNone(), 0);
context->RSSetState(m_states->CullNone());
m_effect->Apply(context);
context->IASetInputLayout(m_layout.Get());
m_batch->Begin();
m_effect->SetView(view);
m_effect->SetProjection(proj);

BoundingSphere worldSphere;
m_bounding.Transform(worldSphere, modelWorld);

DX::Draw(m_batch.get(), worldSphere);
m_batch->End();
#endif

XMMATRIX treeTranslate = XMMatrixTranslation(100, -100, 112);

    // Convert rotation into radians.
    float angle = atan2(100 - m_Camera.Position().x, 112 - m_Camera.Position().z) * (180.0 / XM_PI);
    float treeRot = (float)angle * 0.0174532925f;
    XMMATRIX treeRotation = XMMatrixRotationY(treeRot);
    XMMATRIX treeWorld = treeRotation*treeTranslate; // THIS IS THE IMPORTANT WORLD, THE ROTATION IS IMPORTANT TO INCLUDE

    m_Tree->Draw(m_Graphics.getContext(), states, treeWorld, m_Graphics.getViewMatrix(),
        m_Camera.ProjectionMatrix());

    m_bounding = m_Tree->meshes.at(0)->boundingSphere;

    m_batch->Begin();

    m_bounding.Transform(m_bounding, treeWorld);

    m_effect->SetView(m_Camera.ViewMatrix());
    m_effect->SetProjection(m_Camera.ProjectionMatrix());
    Draw(m_batch.get(), m_bounding, Colors::Red);
    m_batch->End();

BoundingSphere treeSphere;
m_bounding.Transform(treeSphere, treeWorld);

m_effect->SetView(m_Camera.ViewMatrix());
m_effect->SetProjection(m_Camera.ProjectionMatrix());
Draw(m_batch.get(), treeSphere, Colors::Red);
m_batch->End();

void GameApp::Pick(int sx, int sy, XMVECTOR & pickRayInWorldSpacePos, XMVECTOR &pickRayInWorldSpaceDir)
{
    XMVECTOR pickRayInViewSpaceDir = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
    XMVECTOR pickRayInViewSpacePos = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);

    float PRVecX, PRVecY, PRVecZ;
    XMFLOAT4X4 tmp;
    XMStoreFloat4x4(&tmp, m_Camera.ProjectionMatrix());
    //Transform 2D pick position on screen space to 3D ray in View space
    PRVecX = (((2.0f * sx) / 784) - 1) / tmp.m[0][0];
    PRVecY = -(((2.0f * sy) / 562) - 1) / tmp.m[1][1];
    PRVecZ = 1.0f;  //View space's Z direction ranges from 0 to 1, so we set 1 since the ray goes "into" the screen

    pickRayInViewSpaceDir = XMVectorSet(PRVecX, PRVecY, PRVecZ, 0.0f);

    //Uncomment this line if you want to use the center of the screen (client area)
    //to be the point that creates the picking ray (eg. first person shooter)
    //pickRayInViewSpaceDir = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f);

    // Transform 3D Ray from View space to 3D ray in World space
    XMMATRIX pickRayToWorldSpaceMatrix;
    XMVECTOR matInvDeter;   //We don't use this, but the xna matrix inverse function requires the first parameter to not be null

    pickRayToWorldSpaceMatrix = XMMatrixInverse(&matInvDeter, m_Camera.ViewMatrix());   //Inverse of View Space matrix is World space matrix

    pickRayInWorldSpacePos = XMVector3TransformCoord(pickRayInViewSpacePos, pickRayToWorldSpaceMatrix);
    pickRayInWorldSpaceDir = XMVector3TransformNormal(pickRayInViewSpaceDir, pickRayToWorldSpaceMatrix);
    pickRayInWorldSpaceDir = XMVector3Normalize(pickRayInWorldSpaceDir);

    float dist;
    if (m_bounding.Intersects(pickRayInWorldSpacePos, pickRayInWorldSpaceDir, dist) == true)
    {
        m_Picked++;
    }

}