//----------------------------------------------------------------------------
void AmbientRegionActor::_UpdateDirLightCamera()
{
	AVector dir = AVector::AnglesToDirection(Mathf::DEG_TO_RAD*mHorAngle,
		Mathf::DEG_TO_RAD*mVerAngle);
	dir.Normalize();

	Scene *scene = DynamicCast<Scene>(GetTopestParent());
	if (scene)
	{
		EnvirParam *envirParam = scene->GetEnvirParam();

		Light *lightDir = envirParam->GetLight_Dir();
		Projector *projector = envirParam->GetLight_Dir_Projector();

		lightDir->Ambient = Float4(mAmbientColor[0], mAmbientColor[1],
			mAmbientColor[2], mIntensity);
		lightDir->Intensity = mIntensity;
		lightDir->Diffuse = Float4(mDiffuseColor[0], mDiffuseColor[1],
			mDiffuseColor[2], 1.0f);
		lightDir->Specular = Float4(mSpecularColor[0], mSpecularColor[1],
			mSpecularColor[2], mSpecularPow);

		float upDot = dir.Dot(-AVector::UNIT_Z);
		if (upDot >= 0.99f)
		{
		}
		else
		{
			AVector upTemp = AVector::UNIT_Z;
			AVector right = dir.UnitCross(upTemp);
			AVector up = right.UnitCross(dir);

			lightDir->DVector = dir;
			lightDir->UVector = up;
			lightDir->RVector = right;

			APoint camPos = mLightCameraLookPosition - dir*mLightCameraLookDistance;
			projector->SetFrame(camPos, lightDir->DVector,
				lightDir->UVector, lightDir->RVector);
		}

		if (!projector->IsPerspective())
		{
			projector->SetFrustum(0.1f, 100.0f,
				-mLightCameraExtent, mLightCameraExtent, -mLightCameraExtent,
				mLightCameraExtent);
		}
		else
		{
			projector->SetFrustum(mLightCameraExtent, 1.0f, 1.0f, 100.0f);
		}
	}
}
Beispiel #2
0
//----------------------------------------------------------------------------
void ProjectedTextures::CreateScene ()
{
    mScene = new0 Node();
    mTrnNode = new0 Node();
    mScene->AttachChild(mTrnNode);

    // Load the face model.
#ifdef WM5_LITTLE_ENDIAN
    std::string path = Environment::GetPathR("FacePN.wmof");
#else
    std::string path = Environment::GetPathR("FacePN.be.wmof");
#endif
    InStream inStream;
    inStream.Load(path);
    TriMesh* mesh = StaticCast<TriMesh>(inStream.GetObjectAt(0));

    // Create a camera to project the texture.
    Projector* projector = new0 Projector(Camera::PM_DEPTH_ZERO_TO_ONE);
    projector->SetFrustum(1.0f, 10.0f, -0.4125f, 0.4125f, -0.55f, 0.55f);
    AVector proDVector(0.0f, 1.0f, 0.0f);
    AVector proUVector(0.0f, 0.0f, 1.0f);
    AVector proRVector = proDVector.Cross(proUVector);
    APoint proPosition = APoint::ORIGIN - 303.0f*proDVector;
    projector->SetFrame(proPosition, proDVector, proUVector, proRVector);

    // Create a directional light for the face.
    Light* light = new0 Light(Light::LT_DIRECTIONAL);
    light->Ambient = Float4(0.25f, 0.25f, 0.25f, 1.0f);
    light->Diffuse = Float4(1.0f, 1.0f, 1.0f, 1.0f);
    light->Specular = Float4(0.0f, 0.0f, 0.0f, 1.0f);
    light->DVector = AVector::UNIT_Y;  // scene-camera direction

    // Create a material for the face.
    Material* material = new0 Material();
    material->Emissive = Float4(0.0f, 0.0f, 0.0f, 1.0f);
    material->Ambient = Float4(0.5f, 0.5f, 0.5f, 1.0f);
    material->Diffuse = Float4(0.99607f, 0.83920f, 0.67059f, 1.0f);
    material->Specular = Float4(0.8f, 0.8f, 0.8f, 0.0f);

    // Create the effect.
    std::string effectFile = Environment::GetPathR("ProjectedTexture.wmfx");
    ProjectedTextureEffect* effect = new0 ProjectedTextureEffect(effectFile);

    std::string projectedName = Environment::GetPathR("Magician.wmtf");
    Texture2D* projectedTexture = Texture2D::LoadWMTF(projectedName);
    mesh->SetEffectInstance(effect->CreateInstance(projector, light,
        material, projectedTexture));

    mTrnNode->AttachChild(mesh);
}
Beispiel #3
0
//----------------------------------------------------------------------------
void ShadowMaps::CreateShaders ()
{
    // Create the shader constants.  Some of these are shared.

    // Create the light projector.
    Projector* projector = new0 Projector(Camera::PM_DEPTH_ZERO_TO_ONE);
    projector->SetFrustum(60.0f, 1.0f, 0.1f, 100.0f);
    APoint projPosition(4.0f, 4.0f, 4.0f);
    AVector projDVector(-1.0f, -1.0f, -1.0f);
    projDVector.Normalize();
    AVector projUVector(-1.0f, -1.0f, 2.0f);
    projUVector.Normalize();
    AVector projRVector = projDVector.Cross(projUVector);
    projector->SetFrame(projPosition, projDVector, projUVector, projRVector);

    // For SMSceneEffect and SMUnlitEffect.
    ProjectorMatrixConstant* lightPVMatrix =
        new0 ProjectorMatrixConstant(projector, false, 0);

    ShaderFloat* lightBSMatrixUnlit = new0 ShaderFloat(4);
    ShaderFloat* lightBSMatrixScene = new0 ShaderFloat(4);
    ShaderFloat* screenBSMatrix = new0 ShaderFloat(4);
    const float* src;
    if (VertexShader::GetProfile() == VertexShader::VP_ARBVP1)
    {
        src = (const float*)Projector::BiasScaleMatrix[1];
        memcpy(lightBSMatrixUnlit->GetData(), src, 16*sizeof(float));
        memcpy(lightBSMatrixScene->GetData(), src, 16*sizeof(float));
        memcpy(screenBSMatrix->GetData(), src, 16*sizeof(float));
    }
    else
    {
        src = (const float*)Projector::BiasScaleMatrix[0];
        memcpy(lightBSMatrixUnlit->GetData(), src, 16*sizeof(float));
        memcpy(screenBSMatrix->GetData(), src, 16*sizeof(float));
        src = (const float*)Projector::BiasScaleMatrix[1];
        memcpy(lightBSMatrixScene->GetData(), src, 16*sizeof(float));
    }

    // For SMSceneEffect.
    ProjectorWorldPositionConstant* lightWorldPosition =
        new0 ProjectorWorldPositionConstant(projector);

    ShaderFloat* lightColor = new0 ShaderFloat(1);
    (*lightColor)[0] = 1.0f;
    (*lightColor)[1] = 1.0f;
    (*lightColor)[2] = 1.0f;
    (*lightColor)[3] = 1.0f;

    // For SMUnlitEffect.
    ShaderFloat* depthBiasConstant = new0 ShaderFloat(1);
    (*depthBiasConstant)[0] = 0.1f;
    ShaderFloat* texelSizeConstant = new0 ShaderFloat(1);
    (*texelSizeConstant)[0] = 1.0f/(float)mScreenTargetSize;
    (*texelSizeConstant)[1] = 1.0f/(float)mScreenTargetSize;

    // For SMBlurEffect.
    const int numRegisters = 11;
    ShaderFloat* weights = new0 ShaderFloat(numRegisters);
    ShaderFloat* hOffsets = new0 ShaderFloat(numRegisters);
    ShaderFloat* vOffsets = new0 ShaderFloat(numRegisters);

    // Compute the weights.  They must sum to 1.
    Float4* weightsData = (Float4*)weights->GetData();
    const float stdDev = 1.0f;
    const float invTwoVariance = 1.0f/(2.0f*stdDev*stdDev);
    float totalWeight = 0.0f;
    int i, j;
    for (i = 0, j = -numRegisters/2; i < numRegisters; ++i, ++j)
    {
        float weight = Mathf::Exp(-j*j*invTwoVariance);
        weightsData[i] = Float4(weight, weight, weight, 0.0f);
        totalWeight += weight;
    }
    float invTotalWeight = 1.0f/totalWeight;
    for (i = 0; i < numRegisters; ++i)
    {
        weightsData[i][0] *= invTotalWeight;
        weightsData[i][1] *= invTotalWeight;
        weightsData[i][2] *= invTotalWeight;
    }

    // Compute the horizontal and vertical offsets.
    Float4* hOffsetsData = (Float4*)hOffsets->GetData();
    Float4* vOffsetsData = (Float4*)vOffsets->GetData();
    float uDelta = 1.0f/(float)GetWidth();
    float vDelta = 1.0f/(float)GetHeight();
    for (i = 0, j = -numRegisters/2; i < numRegisters; ++i, ++j)
    {
        hOffsetsData[i] = Float4(j*uDelta, 0.0f, 0.0f, 0.0f);
        vOffsetsData[i] = Float4(0.0f, j*vDelta, 0.0f, 0.0f);
    }

    // Create the scene effect.
    std::string effectFile = Environment::GetPathR("SMScene.wmfx");
    SMSceneEffect* sceneEffect = new0 SMSceneEffect(effectFile);

    std::string stoneName = Environment::GetPathR("Stone.wmtf");
    Texture2D* stoneTexture = Texture2D::LoadWMTF(stoneName);
    std::string ballName = Environment::GetPathR("BallTexture.wmtf");
    Texture2D* ballTexture = Texture2D::LoadWMTF(ballName);
    std::string projectedName = Environment::GetPathR("Magician.wmtf");
    Texture2D* projectedTexture = Texture2D::LoadWMTF(projectedName);

    mPlaneSceneInstance = sceneEffect->CreateInstance(lightWorldPosition,
        lightPVMatrix, lightBSMatrixScene, screenBSMatrix, lightColor,
        stoneTexture, mVBlurTarget->GetColorTexture(0), projectedTexture);

    mSphereSceneInstance = sceneEffect->CreateInstance(lightWorldPosition,
        lightPVMatrix, lightBSMatrixScene, screenBSMatrix, lightColor,
        ballTexture, mVBlurTarget->GetColorTexture(0), projectedTexture);

    // Create the shadow effect.
    effectFile = Environment::GetPathR("SMShadow.wmfx");
    mShadowEffect = new0 SMShadowEffect(effectFile, lightPVMatrix);

    // Create the unlit effect.
    effectFile = Environment::GetPathR("SMUnlit.wmfx");
    mUnlitEffect = new0 SMUnlitEffect(effectFile, lightPVMatrix,
        lightBSMatrixUnlit, depthBiasConstant, texelSizeConstant,
        mShadowTarget->GetColorTexture(0));

    // Create the blur effect and instantiate for horizontal and vertical
    // blurring.
    effectFile = Environment::GetPathR("SMBlur.wmfx");
    SMBlurEffect* blurEffect = new0 SMBlurEffect(effectFile);

    mHBlurInstance = blurEffect->CreateInstance(weights, hOffsets,
        mUnlitTarget->GetColorTexture(0));

    mVBlurInstance = blurEffect->CreateInstance(weights, vOffsets,
        mHBlurTarget->GetColorTexture(0));
}