spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#define MAX_STACK_SIZE 64

struct SIdStack
{
    uint Data[MAX_STACK_SIZE];
    uint StackPointer;
};

/* ... */

void StackPop(SIdStack Stack, inout uint StackPointer, out uint Id)
{
    --StackPointer;
    Id = Stack.Data[StackPointer];
}

/* ... */

StackPop(MyStack, MyStack.StackPointer, MyId);

C-/C++-Quelltext

"ERROR 0:220: error X3508: 'StackPop': output parameter 'Id' not completely initialized"

C-/C++-Quelltext

uint StackPop(SIdStack Stack, inout uint StackPointer)

C-/C++-Quelltext

while (!StackEmpty(MyStack))
{
    /* ... */
}

/* ... */

for (uint i = 0; i < NumLights; ++i)
{
    /* ... */
}

C-/C++-Quelltext

/*
 * Lightmap generation D3D11 shader file
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

//****INFO****: Diese Macros dienen nur dazu, um Teile des Codes mit GLSL kompativel zu halten.
#define MUL(m, v)               mul(m, v)
#define CAST(t, v)              ((t)(v))


/* === Macros === */

#define ID_NONE                 0xFFFFFFFF
#define EPSILON                 0.0001

#define PLANE_NORMAL(Plane)     ((Plane).xyz)
#define PLANE_DISTANCE(Plane)   ((Plane).w)

#define SPHERE_POINT(Sphere)    ((Sphere).xyz)
#define SPHERE_RADIUS(Sphere)   ((Sphere).w)

#define SPlane                  float4

#define MAX_STACK_SIZE          64

#define LIGHT_DIRECTIONAL       0
#define LIGHT_POINT             1
#define LIGHT_SPOT              2

#define KDTREE_XAXIS            0
#define KDTREE_YAXIS            1
#define KDTREE_ZAXIS            2


/* === Structures === */

struct STriangle
{
    float3 A, B, C;
};

struct SRay
{
    float3 Origin, Direction;
};

struct SLine
{
    float3 Start, End;
};

struct SKDTreeNode
{
    /* Node construction */
    int Axis;
    float Distance;
    
    /* Content */
    uint TriangleStart; //!< Index to 'TriangleIdList' or ID_NONE
    uint NumTriangles;  //!< Length in 'TriangleIdList' or 0
    
    /* Children pointers */
    uint ChildIds[2];   //!< Index to 'NodeList' or ID_NONE
};

struct SLightSource
{
    int Type;
    float4 Sphere;
    float3 Color;
    float3 Direction;
    float SpotTheta;
    float SpotPhiMinusTheta;
};

struct SLightmapTexel
{
    float3 WorldPos;
    float3 Normal;
    float3 Tangent;
};

struct SIdStack
{
    uint Data[MAX_STACK_SIZE];
    uint StackPointer;
};


/* === Uniforms === */

cbuffer BufferMain : register(b0)
{
    float4x4 WVPMatrix          : packoffset(c0);
    float4 AmbientColor         : packoffset(c4);
    uint NumLights              : packoffset(c5);
    uint2 LightmapSize          : packoffset(c5.y);
};

cbuffer BufferRadiositySetup : register(b1)
{
    uint NumRadiosityRays : packoffset(c0);
    float RadiosityFactor : packoffset(c0.y);   // (1.0 / NumRadiosityRays) * Factor
}

cbuffer BufferRadiosityRays : register(b2)
{
    float4 RadiosityDirections[4096];
};


/*
 * ======= Compute shader: =======
 */

/* === Uniforms === */

StructuredBuffer<SLightSource> LightList : register(t0);
StructuredBuffer<SLightmapTexel> Lightmap : register(t1);   // Active lightmap texels (one draw-call for every lightmap texture)

//****INFO****: Hatte ich zuvor ohne das "RW" aber dann könnte ich das "allow_uav_condition" Attribut nicht verwenden.
// cbuffer nutzen mir hier leider auch nichts.
RWStructuredBuffer<STriangle> TriangleList : register(u2);
RWStructuredBuffer<SKDTreeNode> NodeList : register(u3);
RWBuffer<uint> TriangleIdList : register(u4);

RWTexture2D<float4> OutputLightmap : register(u0);


/* === Functions === */

bool StackEmpty(SIdStack Stack)
{
    return Stack.StackPointer == 0;
}

void StackPush(SIdStack Stack, inout uint StackPointer, uint Id)
{
    Stack.Data[StackPointer] = Id;
    ++StackPointer;
}

uint StackPop(SIdStack Stack, inout uint StackPointer)
{
    --StackPointer;
    return Stack.Data[StackPointer];
}

SPlane BuildPlane(STriangle Tri)
{
    SPlane Plane;
    
    float3 U = Tri.B - Tri.A;
    float3 V = Tri.C - Tri.A;
    
    PLANE_NORMAL(Plane) = normalize(cross(U, V));
    PLANE_DISTANCE(Plane) = dot(PLANE_NORMAL(Plane), Tri.A);
    
    return Plane;
}

bool IntersectionLinePlane(SPlane Plane, SLine Line, out float3 Intersection)
{
    float3 Dir = Line.End - Line.Start;
    float t = (PLANE_DISTANCE(Plane) - dot(PLANE_NORMAL(Plane), Line.Start)) / dot(PLANE_NORMAL(Plane), Dir);
    
    if (t >= 0.0 && t <= 1.0)
    {
        Intersection = Line.Start + Dir * CAST(float3, t);
        return true;
    }
    
    return false;
}

bool IntersectionLineTriangle(STriangle Tri, SLine Line, out float3 Intersection)
{
    float3 pq = Line.End - Line.Start;
    float3 pa = Tri.A - Line.Start;
    float3 pb = Tri.B - Line.Start;
    float3 pc = Tri.C - Line.Start;
    
    /* Check if pq is inside the edges bc, ca and ab */
    Intersection.x = dot(pb, cross(pq, pc));
    if (Intersection.x < 0.0)
        return false;
    
    Intersection.y = dot(pc, cross(pq, pa));
    if (Intersection.y < 0.0)
        return false;
    
    Intersection.z = dot(pa, cross(pq, pb));
    if (Intersection.z < 0.0)
        return false;
    
    return IntersectionLinePlane(BuildPlane(Tri), Line, Intersection);
}

bool OverlapLineTriangle(STriangle Tri, SLine Line)
{
    float3 Intersection = CAST(float3, 0.0);
    
    if (IntersectionLineTriangle(Tri, Line, Intersection))
    {
        return
            distance(Intersection, Line.Start) < EPSILON && 
            distance(Intersection, Line.End) < EPSILON;
    }
    
    return false;
}

void StackPushNodeChildren(SIdStack Stack, inout uint StackPointer, SKDTreeNode Node, SLine Line)
{
    /* Get line segment in other representation */
    float3 Vec = Line.End - Line.Start;
    float tmax = length(Vec);
    Vec = normalize(Vec);
    
    int Axis = Node.Axis;
    int First = (Line.Start[Axis] > Node.Distance);
    
    if (Vec[Axis] == 0.0)
    {
        /* Line segment parallel to splitting plane, visit near side only */
        StackPush(Stack, StackPointer, Node.ChildIds[First]);
    }
    else
    {
        float t = (Node.Distance - Line.Start[Axis]) / Vec[Axis];
        
        /* Check if line segment straddles splitting plane */
        if (t >= 0.0 && t <= tmax)
        {
            /* Traverse near side first, then far side */
            StackPush(Stack, StackPointer, Node.ChildIds[First]);
            StackPush(Stack, StackPointer, Node.ChildIds[First ^ 1]);
        }
        else
        {
            /* Just traverse near side */
            StackPush(Stack, StackPointer, Node.ChildIds[First]);
        }
    }
}

float GetAngle(float3 a, float3 b)
{
    return acos(dot(a, b));
}

float GetSpotLightIntensity(float3 LightDir, SLightSource Light)
{
    /* Compute spot light cone */
    float Angle = GetAngle(LightDir, Light.Direction);
    float ConeAngleLerp = (Angle - Light.SpotTheta) / Light.SpotPhiMinusTheta;
    
    return saturate(1.0 - ConeAngleLerp);
}

void ComputeLightShading(inout float3 Color, SLightSource Light, SLightmapTexel Texel)
{
    /* Compute light direction vector */
    float3 LightDir = CAST(float3, 0.0);
    
    if (Light.Type != LIGHT_DIRECTIONAL)
        LightDir = normalize(Texel.WorldPos - SPHERE_POINT(Light.Sphere));
    else
        LightDir = Light.Direction;
    
    /* Compute phong shading */
    float NdotL = max(0.0, -dot(Texel.Normal, LightDir));
    
    /* Compute light attenuation */
    float Distance = distance(Texel.WorldPos, SPHERE_POINT(Light.Sphere));
    
    float AttnLinear    = Distance * SPHERE_RADIUS(Light.Sphere);
    float AttnQuadratic = AttnLinear * Distance;
    
    float Intensity = 1.0 / (1.0 + AttnLinear + AttnQuadratic);
    
    if (Light.Type == LIGHT_SPOT)
        Intensity *= GetSpotLightIntensity(LightDir, Light);
    
    /* Compute diffuse color */
    Color += Light.Color * CAST(float3, Intensity * NdotL);
}

bool TexelVisibleFromLight(SLightSource Light, SLightmapTexel Texel)
{
    /* Setup line segment */
    SLine Line;
    Line.Start = SPHERE_POINT(Light.Sphere);
    Line.End = Texel.WorldPos;
    
    /* Initialize node ID stack */
    SIdStack Stack;
    for (uint i = 0; i < MAX_STACK_SIZE; ++i)
        Stack.Data[i] = 0;
    Stack.StackPointer = 0;
    
    uint Id = 0;
    StackPush(Stack, Stack.StackPointer, Id);
    
    /* Iterate over all affected tree nodes */
    [allow_uav_condition]
    while (!StackEmpty(Stack))
    {
        /* Get next tree node */
        Id = StackPop(Stack, Stack.StackPointer);
        SKDTreeNode Node = NodeList[Id];
        
        /* Check if this is a node leaf */
        if (Node.TriangleStart != ID_NONE)
        {
            /* Iterate over all triangles inside the tree node */
            [allow_uav_condition]
            //****INFO****: Wenn ich hier nicht "[allow_uav_condition]" davor schreibe,
            //beschwert sich der Compiler, dass die Abbruchbedingung nicht von einem UAV
            //abhängen darf. Mit diesem Attribut kommt aber wieder der Fehler "cannot unroll loop".
            for (uint i = Node.TriangleStart, n = i + Node.NumTriangles; i < n; ++i)
            {
                /* Get current triangle */
                uint TriIndex = TriangleIdList[i];
                STriangle Tri = TriangleList[TriIndex];
                
                /* Make intersection tests */
                if (OverlapLineTriangle(Tri, Line))
                    return false;
            }
        }
        else
        {
            /* Push child nodes which are affected by the line segment */
            //****INFO****: Wenn ich diese Zeile entferne läuft alles, allerdings wird dann halt auch fast alles weg-optimiert.
            StackPushNodeChildren(Stack, Stack.StackPointer, Node, Line);
        }
    }
    
    return true;
}

float3 GetRandomRayDirection(float3x3 NormalMatrix, uint Index)
{
    return MUL(NormalMatrix, RadiosityDirections[Index].xyz);
}

bool SampleLightEnergy(SRay Ray, out float3 Color, out float Distance)
{
    Color = CAST(float3, 0.0);
    Distance = 0.0;
    //todo...
    return false;
}

void ComputeRadiosityShading(inout float3 Color, SRay Ray, float3 TexelNormal)
{
    /* Sampel light energy along specified ray */
    float3 SampleColor = CAST(float3, 0.0);
    float SampleDistance = 0.0;
    
    if (SampleLightEnergy(Ray, SampleColor, SampleDistance))
    {
        /* Add light energy to final texel color */
        float NdotL = max(0.0, dot(TexelNormal, Ray.Direction));
        
        Color += SampleColor * CAST(float3, NdotL * RadiosityFactor);
    }
}

void GenerateLightmapTexel(inout float3 Color, SLightSource Light, SLightmapTexel Texel)
{
    /* Compute direct illumination */
    if (TexelVisibleFromLight(Light, Texel))
        ComputeLightShading(Color, Light, Texel);
    
    /* Compute radiosity */
    if (NumRadiosityRays > 0)
    {
        /* Generate normal matrix (tangent space) */
        float3x3 NormalMatrix = float3x3(
            Texel.Tangent,
            cross(Texel.Normal, Texel.Tangent),
            Texel.Normal
        );
        
        /* Sample radiosity rays */
        SRay Ray;
        Ray.Origin = Texel.WorldPos;
        
        for (uint i = 0; i < NumRadiosityRays; ++i)
        {
            Ray.Direction = GetRandomRayDirection(NormalMatrix, i);
            ComputeRadiosityShading(Color, Ray, Texel.Normal);
        }
    }
}

[numthreads(8, 8, 1)]
void ComputeMain(
    uint3 GroupId : SV_GroupID,
    uint3 LocalId : SV_GroupThreadID,
    uint3 GlobalId : SV_DispatchThreadID)
{
    float4 Color = AmbientColor;
    
    /* Get current lightmap texel */
    uint2 TexelPos = GlobalId.xy;
    SLightmapTexel Texel = Lightmap[TexelPos.y * LightmapSize.x + TexelPos.x];
    
    /* Generate lightmap texel for each light source */
    [allow_uav_condition]
    //****INFO****: Hier kommt der Fehler "forced to unroll loop, but unrolling failed.".
    //Diese Schleife muss aber Dynamisch bleiben.
    for (uint i = 0; i < NumLights; ++i)
        GenerateLightmapTexel(Color.rgb, LightList[i], Texel);
    
    OutputLightmap[TexelPos] = Color;
}

C-/C++-Quelltext

ERROR 0:518: error X3511: forced to unroll loop, but unrolling failed.

C-/C++-Quelltext

Source Type: HLSL
HLSL Compiler: cs_5_0

C-/C++-Quelltext

struct SIdStack
{
    uint Data[MAX_STACK_SIZE];
    uint Pointer;
};
/* ... */
SIdStack Stack;

C-/C++-Quelltext

void StackPush(inout SIdStack Stack, uint Id)
{
    Stack.Data[Stack.Pointer] = Id;
    ++Stack.Pointer;
}

C-/C++-Quelltext

void StackPush(SIdStack Stack, inout uint StackPointer, uint Id)
{
    Stack.Data[StackPointer] = Id;
    ++StackPointer;
}