D3D12_STATIC_SAMPLER_DESC ConvertToStaticSampler(const D3D12_SAMPLER_DESC& samplerDesc, uint32 shaderRegister,
                                                 uint32 registerSpace, D3D12_SHADER_VISIBILITY visibility)
{
    D3D12_STATIC_SAMPLER_DESC staticDesc = { };
    staticDesc.Filter = samplerDesc.Filter;
    staticDesc.AddressU = samplerDesc.AddressU;
    staticDesc.AddressV = samplerDesc.AddressV;
    staticDesc.AddressW = samplerDesc.AddressW;
    staticDesc.MipLODBias = samplerDesc.MipLODBias;
    staticDesc.MaxAnisotropy = samplerDesc.MaxAnisotropy;
    staticDesc.ComparisonFunc = samplerDesc.ComparisonFunc;
    staticDesc.MinLOD = samplerDesc.MinLOD;
    staticDesc.MaxLOD = samplerDesc.MaxLOD;
    staticDesc.ShaderRegister = shaderRegister;
    staticDesc.RegisterSpace = registerSpace;
    staticDesc.ShaderVisibility = visibility;

    Float4 borderColor = Float4(samplerDesc.BorderColor[0], samplerDesc.BorderColor[1], samplerDesc.BorderColor[2], samplerDesc.BorderColor[3]);
    if(borderColor == Float4(1.0f, 1.0f, 1.0f, 1.0f))
        staticDesc.BorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE;
    else if(borderColor == Float4(0.0f, 0.0f, 0.0f, 1.0f))
        staticDesc.BorderColor = D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK;
    else
        staticDesc.BorderColor =  D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;

    return staticDesc;
}

//----------------------------------------------------------------------------
void Delaunay3D::DoSearch ()
{
    // Make all tetra wireframe.
    const int numSimplices = mDelaunay->GetNumSimplices();
    Float4 lightGray(0.75f, 0.75f, 0.75f, 1.0f);
    int i;
    for (i = 0; i < numSimplices; ++i)
    {
        ChangeTetraStatus(i, lightGray, true);
    }

    // Generate random point in AABB of data set.
    Vector3f random;
    random.X() = Mathf::IntervalRandom(mMin.X(), mMax.X());
    random.Y() = Mathf::IntervalRandom(mMin.Y(), mMax.Y());
    random.Z() = Mathf::IntervalRandom(mMin.Z(), mMax.Z());

    // Move sphere to this location.
    Spatial* sphere = mScene->GetChild(0);
    sphere->Culling = Spatial::CULL_DYNAMIC;
    sphere->LocalTransform.SetTranslate(random);
    sphere->Update();

    if (mDelaunay->GetContainingTetrahedron(random) >= 0)
    {
        // Make all tetra on the path solid.
        const int pathLast = mDelaunay->GetPathLast();
        for (i = 0; i <= pathLast; ++i)
        {
            int index = mDelaunay->GetPath()[i];
            float red, blue;
            if (pathLast > 0)
            {
                red = i/(float)pathLast;
                blue = 1.0f - red;
            }
            else
            {
                red = 1.0f;
                blue = 0.0f;
            }
            ChangeTetraStatus(index, Float4(red, 0.0f, blue, 0.5f), false);
        }
    }
    else
    {
        // The point is outside the convex hull.  Change the wireframe
        // color for the last visited face in the search path.
        int index = mDelaunay->GetPath()[mDelaunay->GetPathLast()];
        int v0, v1, v2, v3;
        int vOpposite = mDelaunay->GetLastFace(v0, v1, v2, v3);
        ChangeLastTetraStatus(index, vOpposite,
            Float4(0.0f, 1.0f, 0.0f, 0.5f),
            Float4(0.0f, 0.25f, 0.0f, 0.5f));
    }

    mCuller.ComputeVisibleSet(mScene);
}

LightDescPoint::LightDescPoint()
{
	ambient		= Float4(0.0f, 0.0f, 0.0f, 0.0f);
	diffuse		= Float4(0.0f, 0.0f, 0.0f, 0.0f);
	specular	= Float4(0.0f, 0.0f, 0.0f, 0.0f);

	range		= 0.0f;
	attenuation	= Float3(0.0f, 0.0f, 0.0f);
}

void GrassModule::OnGrassClick(const MGUI::MouseEvent * e)
{
	if (mImageBox_Selected)
		mImageBox_Selected->SetColor(Float4(1.0f, 1.0f, 1.0f));

	mImageBox_Selected = (MGUI::ImageBox *)e->sender;

	if (mImageBox_Selected)
		mImageBox_Selected->SetColor(Float4(0.7f, 0.7f, 1.0f));
}

 Point lerp3d(const Point& px0y0z0, const Point& px1y0z0, const Point& px0y1z0, const Point& px1y1z0,
     const Point& px0y0z1, const Point& px1y0z1, const Point& px0y1z1, const Point& px1y1z1,
     float xPoint, float yPoint, float zPoint) {
         return Point(lerp3d(Float4(px0y0z0), Float4(px1y0z0), Float4(px0y1z0), Float4(px1y1z0), 
             Float4(px0y0z1), Float4(px1y0z1), Float4(px0y1z1), Float4(px1y1z1), 
             xPoint, yPoint, zPoint));
 }

Float4 Quaternion::getAxisAndAngle() const
{
    float ha = std::acos(w);
    float sha = std::sin(ha);

    return Float4(x / sha, y / sha, z / sha, ha*2.0f);
}

void GrassModule::OnRender()
{
	if (!mLayout->IsVisible() || mImageBox_Selected == NULL || !Terrain::Instance()->IsValid())
		return ;

	Aabb aabb;
	aabb.minimum = mBrushPosition - Float3(mBrushSize * 0.5f, 1, mBrushSize * 0.5f);
	aabb.maximum = mBrushPosition + Float3(mBrushSize * 0.5f, 1, mBrushSize * 0.5f);

	RenderSystem::Instance()->SetWorldTM(Mat4::Identity);

	for (int y = 0; y < Terrain::Instance()->GetInfo()->BlockCount.x; ++y)
	{
		for (int x = 0; x < Terrain::Instance()->GetInfo()->BlockCount.y; ++x)
		{
			TerrainMesh * mesh = Terrain::Instance()->_getBlock(x, y);
			const Aabb & bound = mesh->GetWorldAabb();

			float x0 = Max(aabb.minimum.x, bound.minimum.x);
			float z0 = Max(aabb.minimum.z, bound.minimum.z);

			float x1 = Min(aabb.maximum.x, bound.maximum.x);
			float z1 = Min(aabb.maximum.z, bound.maximum.z);

			if (x0 <= x1 && z0 <= z1)
			{
				mShaderFX_Brush->GetPass(0)->SetConst("u_MinInvSize", Float4(aabb.minimum.x, aabb.minimum.z, 1 / mBrushSize, 1 / mBrushSize));
				mShaderFX_Brush->GetPass(0)->SetConst("u_XZTransform", mesh->GetXZTransform());

				RenderSystem::Instance()->SetTexture(0, MGUI::Helper::Instance()->GetWhiteTexture().c_ptr());
				RenderSystem::Instance()->Render(mShaderFX_Brush, mesh->GetRenderOp());
			}
		}
	}
}

//----------------------------------------------------------------------------
BSplineSurfaceFitter::BSplineSurfaceFitter ()
	:
	WindowApplication3("SampleMathematics/BSplineSurfaceFitter", 0, 0, 640,
	                   480, Float4(0.0f, 0.5f, 0.75f, 1.0f)),
	mTextColor(0.0f, 0.0f, 0.0f, 1.0f)
{
}

//----------------------------------------------------------------------------
PolyhedronDistance::PolyhedronDistance ()
    :
    WindowApplication3("SamplePhysics/PolyhedronDistance", 0, 0, 640, 480,
        Float4(0.5f, 0.0f, 1.0f, 1.0f)),
        mTextColor(1.0f, 1.0f, 1.0f, 1.0f)
{
}

//----------------------------------------------------------------------------
FoucaultPendulum::FoucaultPendulum ()
    :
    WindowApplication3("SamplePhysics/FoucaultPendulum", 0, 0, 640, 480,
        Float4(0.819607f, 0.909803f, 0.713725f, 1.0f)),
        mTextColor(1.0f, 1.0f, 1.0f, 1.0f)
{
}

//----------------------------------------------------------------------------
RoughPlaneThinRod2::RoughPlaneThinRod2 ()
	:
	WindowApplication2("SamplePhysics/RoughPlaneThinRod2", 0, 0, 256, 256,
	                   Float4(1.0f, 1.0f, 1.0f, 1.0f))
{
	mSize = GetWidth();
}

//----------------------------------------------------------------------------
BillboardNodes::BillboardNodes ()
    :
    WindowApplication3("SampleGraphics/BillboardNodes",0, 0, 640, 480,
        Float4(0.9f, 0.9f, 0.9f, 1.0f)),
        mTextColor(1.0f, 1.0f, 1.0f, 1.0f)
{
}

//----------------------------------------------------------------------------
ClodMeshes::ClodMeshes ()
    :
    WindowApplication3("SampleGraphics/ClodMeshes", 0, 0, 640, 480,
        Float4(0.9f, 0.9f, 0.9f, 1.0f)),
        mTextColor(0.0f, 0.0f, 0.0f, 1.0f)
{
}

			const Ray operator * ( const Ray& lhs, const Matrix4x4& world )
			{
				const Float3 origin = lhs.origin * world;
				const Float3 direction = ( Float4( lhs.direction, 0 ) * world );
				Ray result( origin, direction );
				return result;
			}

//----------------------------------------------------------------------------
NonuniformScale::NonuniformScale ()
    :
    WindowApplication3("SampleGraphics/NonuniformScale", 0, 0, 640, 480,
        Float4(0.5f, 0.0f, 1.0f, 1.0f)),
        mTextColor(1.0f, 1.0f, 1.0f, 1.0f)
{
}

//----------------------------------------------------------------------------
BlendedAnimations::BlendedAnimations ()
	:
	WindowApplication3("SampleGraphics/BlendedAnimations", 0, 0, 768, 768,
	                   Float4(0.5f, 0.0f, 1.0f, 1.0f)),
	mTextColor(1.0f, 1.0f, 1.0f, 1.0f),
	mManager(ThePath + "Data/", "Biped"),
	mAnimTime(0.0),
	mUpArrowPressed(false),
	mShiftPressed(false)
{
	// Set animation information.  The counts differ in debug and release
	// builds because of the differing frame rates of those builds.
#ifdef _DEBUG
	int idleWalkCount = 100;
	int walkCount = 10;
	int walkRunCount = 100;
	mAnimTimeDelta = 0.01;
#else
	int idleWalkCount = 1000;
	int walkCount = 100;
	int walkRunCount = 1000;
	mAnimTimeDelta = 0.001;
#endif

	// The idle head turning occurs too frequently (frequency = 1 in the
	// original model).  Reduce the turning by half.
	mManager.SetIdle(0.5, 0.0);

	// The walk and run cycles must be aligned properly for blending.  A
	// phase of 0.2 for the run cycle aligns the biped feet.
	mManager.SetRun(1.0, 0.2);

	// The initial state is 'idle'.
	mManager.Initialize(idleWalkCount, walkCount, walkRunCount);
}

//----------------------------------------------------------------------------
ClipMesh::ClipMesh ()
    :
    WindowApplication3("SampleMathematics/ClipMesh", 0, 0, 640, 480,
        Float4(0.75f, 0.75f, 0.75f, 1.0f)),
        mTextColor(1.0f, 1.0f, 1.0f, 1.0f)
{
}

//----------------------------------------------------------------------------
PolygonDistance::PolygonDistance ()
	:
	WindowApplication2("SamplePhysics/PolygonDistance", 0, 0, 512, 512,
	                   Float4(1.0f, 1.0f, 1.0f, 1.0f))
{
	mSize = GetWidth();
}

	virtual void OnInit()
	{
		MGUI::FontManager::Instance()->Load("Sample.font");
		MGUI::InputManager::Instance()->E_MouseUp += new ncListener1<const MGUI::MouseEvent *>(OnPick);
		MGUI::InputManager::Instance()->E_TouchUp += new ncListener1<const MGUI::TouchEvent *>(OnPickTE);

		World::Instance()->MainRenderContext()->SetColorClear(eClearMode::ALL, Float4(0.15f, 0.15f, 0.15f));
		World::Instance()->MainCamera()->SetPosition(Float3(0, 5, -10));
		World::Instance()->MainCamera()->SetDirection(Float3(0, -5, 10));
		World::Instance()->MainLight()->SetDirection(Float3(0, -0.5f, 1));

		gMeshFloor = MeshManager::Instance()->NewPlane(Plane(0, 1, 0, 0), 10, 10);
		gMeshFloor->GetSubMesh(0)->GetMaterial()->ambient = Float3(0.3f, 0.0f, 0.3f);
		gMeshFloor->GetSubMesh(0)->GetMaterial()->diffuse = Float3(0.0f, 0.0f, 0.0f);

		gMeshBox = MeshManager::Instance()->NewBox(1, 1, 1);
		gMeshBox->GetSubMesh(0)->GetMaterial()->ambient = Float3(0.1f, 0.1f, 0.1f);
		gMeshBox->GetSubMesh(0)->GetMaterial()->diffuse = Float3(0.0f, 0.5f, 0.0f);
		gMeshBox->SetPosition(Float3(0, 3, 0));

		PhyWorld::Instance()->SetWorldGravity(0, -9.8f, 0);
		PhyWorld::Instance()->SetWorldContactSurfaceLayer(0.01f);

		gPhyEntityFloor = new PhyPlane;
		gPhyEntityFloor->SetCollisionFlag(FLAG_FLOOR);

		gPhyEntityBox = new PhyBox(PhyEntity::RIGID_BODY);
		gPhyEntityBox->SetBodyAutoDisable(false);
		gPhyEntityBox->SetLength(1, 1, 1);
		gPhyEntityBox->SetMass(5, 1, 1, 1);
		gPhyEntityBox->SetPosition(Float3(0, 3, 0));
		gPhyEntityBox->SetBounceParam(1.0f, 1.0f);
		gPhyEntityBox->SetCollisionFlag(FLAG_BOX);
		gPhyEntityBox->SetAngularVel(Float3(2, 2, 2));
	}

void ExplosionSpherePhysicsObject::onUpdate(float delta)
{
	//--------------------------------------------------------------------------------------
	// Update scaling. Expand explosion sphere according to mutator settings retrieved in "subClassSpecificInitHook()"
	//--------------------------------------------------------------------------------------
	std::vector<int> explosionSphereEntityId = itrPhysics.ownerAt(attributeIndex_)->getAttributes(ATTRIBUTE_EXPLOSIONSPHERE);
	for(unsigned int i = 0; i < explosionSphereEntityId.size(); i++)
	{
		AttributePtr<Attribute_ExplosionSphere> ptr_explosionSphere = itrExplosionSphere.at(explosionSphereEntityId.at(i));
		ptr_explosionSphere->currentRadius += explosionSphereExpansionRate_*delta;
		if(ptr_explosionSphere->currentRadius >= explosionSphereFinalRadius_)
		{
			ptr_explosionSphere->currentRadius = explosionSphereFinalRadius_;
		}
		itrPhysics.at(attributeIndex_)->ptr_spatial->scale = Float3(ptr_explosionSphere->currentRadius,ptr_explosionSphere->currentRadius,ptr_explosionSphere->currentRadius);
		localCollisionShape_->setLocalScaling(btVector3(ptr_explosionSphere->currentRadius, ptr_explosionSphere->currentRadius, ptr_explosionSphere->currentRadius));
	}

	//--------------------------------------------------------------------------------------
	// Update rotation
	//--------------------------------------------------------------------------------------
	btQuaternion randomRotationQuaternion (randomRotation_.x()*delta,randomRotation_.y()*delta,randomRotation_.z()*delta);
	btQuaternion rotateWithRandomRotationQuaternion = randomRotationQuaternion*getWorldTransform().getRotation();
	getWorldTransform().setRotation(rotateWithRandomRotationQuaternion);
	itrPhysics.at(attributeIndex_)->ptr_spatial->rotation = Float4(rotateWithRandomRotationQuaternion.x(),rotateWithRandomRotationQuaternion.y(),rotateWithRandomRotationQuaternion.z(),rotateWithRandomRotationQuaternion.w());
}