spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void Terrain::RenderPatch(GraphicsDevice* device, Camera *camera, 
                          float offsetHeightX, float offsetHeightY, float scaleHeight, 
                          float offsetPositionX, float offsetPositionY, float scalePosition, 
                          int level)
{


    float centerX = offsetPositionX + _patchSize * scalePosition * 0.5f;
    float centerZ = offsetPositionY - _patchSize * scalePosition * 0.5f;
    XMFLOAT3 patchCenter(centerX, 0.0f, centerZ);
    float triangleSize = scalePosition;

    float distance;
    XMStoreFloat(&distance, XMVector3Length(XMLoadFloat3(&patchCenter) - XMLoadFloat3(&camera->GetPosition())));

    float distanceToSizeQuotient = distance / triangleSize;

    if (distanceToSizeQuotient > _lodParameter || level < 1)
    {
        _terrainEffect->SetTerrainPatchData(XMFLOAT2(offsetHeightX, offsetHeightY), scaleHeight, XMFLOAT2(offsetPositionX, offsetPositionY), scalePosition);
        _terrainEffect->Apply(device->GetImmediateContext());
        device->DrawIndexed(_indexCount);
    }
    else
    {
        float halfHeightMapSize = scaleHeight * 0.5f;
        float halfScalePosition = scalePosition * 0.5f;
        RenderPatch(device, camera, offsetHeightX, offsetHeightY, halfHeightMapSize, 
                                     offsetPositionX, offsetPositionY, halfScalePosition, level-1);

        RenderPatch(device, camera, offsetHeightX+halfHeightMapSize, offsetHeightY, halfHeightMapSize, 
                                     centerX, offsetPositionY, halfScalePosition, level-1);

        RenderPatch(device, camera, offsetHeightX, offsetHeightY+halfHeightMapSize, halfHeightMapSize, 
                                     offsetPositionX, centerZ, halfScalePosition, level-1);

        RenderPatch(device, camera, offsetHeightX+halfHeightMapSize, offsetHeightY+halfHeightMapSize, halfHeightMapSize, 
                                     centerX, centerZ, halfScalePosition, level-1);
    }
}

C-/C++-Quelltext

void Terrain::CustomDraw(GraphicsDevice* device, SceneNode *sceneNode, Camera *camera)
{
    //Vorbereitung zum Rendern etc. .... weggelasen
    
    float scalePosition = _terrainSize / _patchSize;
    float scaleHeightMap = 1.0f;

        //Parameter 3,4 und 5 sind die Texturkoordinaten für die heightmap, also 0,0,1
    RenderPatch(device, camera, 0,0, scaleHeightMap, -_terrainSize * 0.5f, _terrainSize * 0.5f, scalePosition, _maxLevels);
}

HLSL-Quelltext

cbuffer cbPerScene
{
    float3 LightDir = float3(1.0f,-3,1.0f);
    float3 CameraPosition;
    float HeightMapScale = 200.0f;
    float2 TileBase = float2(10.0f, 10.0f);
}

cbuffer cbPerObject
{
    float4x4 WorldViewProjection;
    float2 PosOffset = 0;
    float PosScale = 1;
    float2 HeightOffset = 0.0;
    float HeightScale = 1.0;
}

Texture2D HeightMap;

SamplerState HeightMapSampler
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = CLAMP;
    AddressV = CLAMP;
};

struct VertexInput
{
    float3 Position : POSITION0;
    float2 Texcoord : TEXCOORD0;
};

struct VertexOutput
{
    float4 Position   : SV_POSITION;
    float2 Texcoord   : TEXCOORD0;
};

float3 GetNormalFromHeightMap(Texture2D tex, SamplerState samp, float2 texCoord, float offsetToNextPixel)
{
    float2 offsets[4];
    offsets[0] = texCoord + float2(-offsetToNextPixel, 0);
    offsets[1] = texCoord + float2(offsetToNextPixel, 0);
    offsets[2] = texCoord + float2(0, -offsetToNextPixel);
    offsets[3] = texCoord + float2(0, offsetToNextPixel);

    float hts[4];

    for(int i = 0; i < 4; i++)
    {
        hts[i] = tex.SampleLevel(samp, offsets[i], 0).x * HeightMapScale;
    }

    const float cellSpace = 1.0f;

    float3 tangent = normalize(float3(2.0f * cellSpace, hts[1] - hts[0], 0.0f));
    float3 bitangent = normalize(float3(0.0f, hts[3] - hts[2], -2.0f * cellSpace));

    return normalize(cross(tangent, bitangent)).xyz;
}

float4 PSMain(VertexOutput input) : SV_TARGET
{
    //relevante Zeile. Ermittelt die Normale.
    float3 normal = normalize(GetNormalFromHeightMap(HeightMap, HeightMapSampler, HeightOffset + input.Texcoord * HeightScale, 1.0f / 64.0f));

    float diffuseFactor = saturate(dot(normal, normalize(-LightDir)));
    float4 materialTextureColor = DiffuseTexture.Sample(DiffuseMapSampler, input.Texcoord * TileBase);
    
    return materialTextureColor * diffuseFactor;
}