public override void LoadContent(DeviceContext context)
        {
            _cubeRenderer.LoadContent(context);

            _voxelModelEffect = ToDispose(new HLSLVoxelModel(context.Device, ClientSettings.EffectPack + @"Entities\VoxelModel.hlsl", VertexVoxel.VertexDeclaration));

            Tool = _player.Equipment.RightTool;

            _playerModel = _voxelModelManager.GetModel(_player.ModelName);
            if (_playerModel != null)
            {
                if (!_playerModel.Initialized)
                {
                    _playerModel.BuildMesh();
                }

                if (_player.ModelInstance == null)
                {
                    _player.ModelInstance = _playerModel.VoxelModel.CreateInstance();

                    //Get Voxel Arm of the character.
                    var armPartIndex = _player.ModelInstance.VoxelModel.GetArmIndex();
                    _handVoxelModel       = _player.ModelInstance.VoxelModel.Parts[armPartIndex];
                    _handState            = _player.ModelInstance.VoxelModel.GetMainState().PartsStates[armPartIndex];
                    _handVisualVoxelModel = _playerModel.VisualVoxelFrames[armPartIndex];
                }
            }
        }
        private static bool IsCollidingWithModel(VisualEntity entityTesting, BoundingBox playerBoundingBox2Evaluate)
        {
            var visualVoxelEntity = entityTesting as VisualVoxelEntity;

            if (visualVoxelEntity == null)
            {
                return(false);
            }

            var instance = visualVoxelEntity.VoxelEntity.ModelInstance;

            if (instance == null)
            {
                return(false);
            }

            int  index;
            bool collisionDetected = false;
            //Check Against all existing "Sub-Cube" model

            //Get current Active state = A model can have multiple "State" (Like open, close, mid open, ...)
            var activeModelState = instance.State;

            var visualModel = visualVoxelEntity.VisualVoxelModel;

            //For each Part in the model (A model can be composed of several parts)
            for (int partId = 0; partId < visualModel.VoxelModel.Parts.Count && !collisionDetected; partId++)
            {
                VoxelModelPartState partState = activeModelState.PartsStates[partId];

                // it is possible that there is no frame, so no need to check anything
                if (partState.ActiveFrame == byte.MaxValue)
                {
                    continue;
                }

                VoxelModelPart part             = visualModel.VoxelModel.Parts[partId];
                BoundingBox    frameBoundingBox = visualModel.VisualVoxelFrames[partState.ActiveFrame].BoundingBox;

                //Get Current Active part Frame = In animation case, the frame will be different when time passing by ... (Time depends)
                var activeframe = visualModel.VoxelModel.Frames[partState.ActiveFrame]; //one active at a time

                Matrix invertedEntityWorldMatrix = partState.GetTransformation() * Matrix.RotationQuaternion(instance.Rotation) * instance.World;
                invertedEntityWorldMatrix.Invert();

                BoundingBox PlayerBBInEntitySpace = playerBoundingBox2Evaluate.Transform(invertedEntityWorldMatrix);

                // if we don't intersect part BB then there is no reason to check each block BB
                if (!frameBoundingBox.Intersects(ref PlayerBBInEntitySpace))
                {
                    continue;
                }

                //Check each frame Body part
                Vector3I chunkSize = activeframe.BlockData.ChunkSize;
                byte[]   data      = activeframe.BlockData.BlockBytes;

                index = -1;
                //Get all sub block not empty
                for (int z = 0; z < chunkSize.Z && !collisionDetected; z++)
                {
                    for (int x = 0; x < chunkSize.X && !collisionDetected; x++)
                    {
                        for (int y = 0; y < chunkSize.Y && !collisionDetected; y++)
                        {
                            index++;

                            //Get cube
                            if (data[index] > 0)
                            {
                                //Collision checking against this point.

                                if (PlayerBBInEntitySpace.Minimum.X > x + 1 || x > PlayerBBInEntitySpace.Maximum.X)
                                {
                                    continue; //No collision
                                }
                                if (PlayerBBInEntitySpace.Minimum.Y > y + 1 || y > PlayerBBInEntitySpace.Maximum.Y)
                                {
                                    continue; //No collision
                                }
                                if (PlayerBBInEntitySpace.Minimum.Z > z + 1 || z > PlayerBBInEntitySpace.Maximum.Z)
                                {
                                    continue; //No collision
                                }
                                //Collision HERE !!!
                                collisionDetected = true;
                            }
                        }
                    }
                }
            }

            return(collisionDetected);
        }