LightingRendering.cpp
/** The stencil sphere vertex buffer. */
TGlobalResource<StencilingGeometry::TStencilSphereVertexBuffer<18, 12, FVector4> > StencilingGeometry::GStencilSphereVertexBuffer;
TGlobalResource<StencilingGeometry::TStencilSphereVertexBuffer<18, 12, FVector> > StencilingGeometry::GStencilSphereVectorBuffer;
/** The stencil sphere index buffer. */
TGlobalResource<StencilingGeometry::TStencilSphereIndexBuffer<18, 12> > StencilingGeometry::GStencilSphereIndexBuffer;
TGlobalResource<StencilingGeometry::TStencilSphereVertexBuffer<4, 4, FVector4> > StencilingGeometry::GLowPolyStencilSphereVertexBuffer;
TGlobalResource<StencilingGeometry::TStencilSphereIndexBuffer<4, 4> > StencilingGeometry::GLowPolyStencilSphereIndexBuffer;
/** The (dummy) stencil cone vertex buffer. */
TGlobalResource<StencilingGeometry::FStencilConeVertexBuffer> StencilingGeometry::GStencilConeVertexBuffer;
/** The stencil cone index buffer. */
TGlobalResource<StencilingGeometry::FStencilConeIndexBuffer> StencilingGeometry::GStencilConeIndexBuffer;
void StencilingGeometry::DrawSphere(FRHICommandList& RHICmdList)
{
RHICmdList.SetStreamSource(0, StencilingGeometry::GStencilSphereVertexBuffer.VertexBufferRHI, 0);
RHICmdList.DrawIndexedPrimitive(StencilingGeometry::GStencilSphereIndexBuffer.IndexBufferRHI, 0, 0,
StencilingGeometry::GStencilSphereVertexBuffer.GetVertexCount(), 0,
StencilingGeometry::GStencilSphereIndexBuffer.GetIndexCount() / 3, 1);
}
void StencilingGeometry::DrawVectorSphere(FRHICommandList& RHICmdList)
{
RHICmdList.SetStreamSource(0, StencilingGeometry::GStencilSphereVectorBuffer.VertexBufferRHI, 0);
RHICmdList.DrawIndexedPrimitive(StencilingGeometry::GStencilSphereIndexBuffer.IndexBufferRHI, 0, 0,
StencilingGeometry::GStencilSphereVectorBuffer.GetVertexCount(), 0,
StencilingGeometry::GStencilSphereIndexBuffer.GetIndexCount() / 3, 1);
}
void StencilingGeometry::DrawCone(FRHICommandList& RHICmdList)
{
// No Stream Source needed since it will generate vertices on the fly
RHICmdList.SetStreamSource(0, StencilingGeometry::GStencilConeVertexBuffer.VertexBufferRHI, 0);
RHICmdList.DrawIndexedPrimitive(StencilingGeometry::GStencilConeIndexBuffer.IndexBufferRHI, 0, 0,
FStencilConeIndexBuffer::NumVerts, 0, StencilingGeometry::GStencilConeIndexBuffer.GetIndexCount() / 3, 1);
}LightingRendering.h
/** Utility functions for drawing a sphere */
namespace StencilingGeometry
{
/**
* Draws a sphere using RHIDrawIndexedPrimitive, useful as approximate bounding geometry for deferred passes.
* Note: The sphere will be of unit size unless transformed by the shader.
*/
extern void DrawSphere(FRHICommandList& RHICmdList);
/**
* Draws exactly the same as above, but uses FVector rather than FVector4 vertex data.
*/
extern void DrawVectorSphere(FRHICommandList& RHICmdList);
/** Renders a cone with a spherical cap, used for rendering spot lights in deferred passes. */
extern void DrawCone(FRHICommandList& RHICmdList);
/**
* Vertex buffer for a sphere of unit size. Used for drawing a sphere as approximate bounding geometry for deferred passes.
*/
template<int32 NumSphereSides, int32 NumSphereRings, typename VectorType>
class TStencilSphereVertexBuffer : public FVertexBuffer
{
public:
int32 GetNumRings() const
{
return NumSphereRings;
}
/**
* Initialize the RHI for this rendering resource
*/
void InitRHI() override
{
const int32 NumSides = NumSphereSides;
const int32 NumRings = NumSphereRings;
const int32 NumVerts = (NumSides + 1) * (NumRings + 1);
const float RadiansPerRingSegment = PI / (float)NumRings;
float Radius = 1;
TArray<VectorType, TInlineAllocator<NumRings + 1> > ArcVerts;
ArcVerts.Empty(NumRings + 1);
// Calculate verts for one arc
for (int32 i = 0; i < NumRings + 1; i++)
{
const float Angle = i * RadiansPerRingSegment;
ArcVerts.Add(FVector(0.0f, FMath::Sin(Angle), FMath::Cos(Angle)));
}
TResourceArray<VectorType, VERTEXBUFFER_ALIGNMENT> Verts;
Verts.Empty(NumVerts);
// Then rotate this arc NumSides + 1 times.
const FVector Center = FVector(0,0,0);
for (int32 s = 0; s < NumSides + 1; s++)
{
FRotator ArcRotator(0, 360.f * ((float)s / NumSides), 0);
FRotationMatrix ArcRot( ArcRotator );
for (int32 v = 0; v < NumRings + 1; v++)
{
const int32 VIx = (NumRings + 1) * s + v;
Verts.Add(Center + Radius * ArcRot.TransformPosition(ArcVerts[v]));
}
}
NumSphereVerts = Verts.Num();
uint32 Size = Verts.GetResourceDataSize();
// Create vertex buffer. Fill buffer with initial data upon creation
FRHIResourceCreateInfo CreateInfo(&Verts);
VertexBufferRHI = RHICreateVertexBuffer(Size,BUF_Static,CreateInfo);
}
int32 GetVertexCount() const { return NumSphereVerts; }
/**
* Calculates the world transform for a sphere.
* @param OutTransform - The output world transform.
* @param Sphere - The sphere to generate the transform for.
* @param PreViewTranslation - The pre-view translation to apply to the transform.
* @param bConservativelyBoundSphere - when true, the sphere that is drawn will contain all positions in the analytical sphere,
* Otherwise the sphere vertices will lie on the analytical sphere and the positions on the faces will lie inside the sphere.
*/
void CalcTransform(FVector4& OutPosAndScale, const FSphere& Sphere, const FVector& PreViewTranslation, bool bConservativelyBoundSphere = true)
{
float Radius = Sphere.W;
if (bConservativelyBoundSphere)
{
const int32 NumRings = NumSphereRings;
const float RadiansPerRingSegment = PI / (float)NumRings;
// Boost the effective radius so that the edges of the sphere approximation lie on the sphere, instead of the vertices
Radius /= FMath::Cos(RadiansPerRingSegment);
}
const FVector Translate(Sphere.Center + PreViewTranslation);
OutPosAndScale = FVector4(Translate, Radius);
}
private:
int32 NumSphereVerts;
};
/**
* Stenciling sphere index buffer
*/
template<int32 NumSphereSides, int32 NumSphereRings>
class TStencilSphereIndexBuffer : public FIndexBuffer
{
public:
/**
* Initialize the RHI for this rendering resource
*/
void InitRHI() override
{
const int32 NumSides = NumSphereSides;
const int32 NumRings = NumSphereRings;
TResourceArray<uint16, INDEXBUFFER_ALIGNMENT> Indices;
// Add triangles for all the vertices generated
for (int32 s = 0; s < NumSides; s++)
{
const int32 a0start = (s + 0) * (NumRings + 1);
const int32 a1start = (s + 1) * (NumRings + 1);
for (int32 r = 0; r < NumRings; r++)
{
Indices.Add(a0start + r + 0);
Indices.Add(a1start + r + 0);
Indices.Add(a0start + r + 1);
Indices.Add(a1start + r + 0);
Indices.Add(a1start + r + 1);
Indices.Add(a0start + r + 1);
}
}
NumIndices = Indices.Num();
const uint32 Size = Indices.GetResourceDataSize();
const uint32 Stride = sizeof(uint16);
// Create index buffer. Fill buffer with initial data upon creation
FRHIResourceCreateInfo CreateInfo(&Indices);
IndexBufferRHI = RHICreateIndexBuffer(Stride, Size, BUF_Static, CreateInfo);
}
int32 GetIndexCount() const { return NumIndices; };
private:
int32 NumIndices;
};
class FStencilConeIndexBuffer : public FIndexBuffer
{
public:
// A side is a line of vertices going from the cone's origin to the edge of its SphereRadius
static const int32 NumSides = 18;
// A slice is a circle of vertices in the cone's XY plane
static const int32 NumSlices = 12;
static const uint32 NumVerts = NumSides * NumSlices * 2;
void InitRHI() override
{
TResourceArray<uint16, INDEXBUFFER_ALIGNMENT> Indices;
Indices.Empty((NumSlices - 1) * NumSides * 12);
// Generate triangles for the vertices of the cone shape
for (int32 SliceIndex = 0; SliceIndex < NumSlices - 1; SliceIndex++)
{
for (int32 SideIndex = 0; SideIndex < NumSides; SideIndex++)
{
const int32 CurrentIndex = SliceIndex * NumSides + SideIndex % NumSides;
const int32 NextSideIndex = SliceIndex * NumSides + (SideIndex + 1) % NumSides;
const int32 NextSliceIndex = (SliceIndex + 1) * NumSides + SideIndex % NumSides;
const int32 NextSliceAndSideIndex = (SliceIndex + 1) * NumSides + (SideIndex + 1) % NumSides;
Indices.Add(CurrentIndex);
Indices.Add(NextSideIndex);
Indices.Add(NextSliceIndex);
Indices.Add(NextSliceIndex);
Indices.Add(NextSideIndex);
Indices.Add(NextSliceAndSideIndex);
}
}
// Generate triangles for the vertices of the spherical cap
const int32 CapIndexStart = NumSides * NumSlices;
for (int32 SliceIndex = 0; SliceIndex < NumSlices - 1; SliceIndex++)
{
for (int32 SideIndex = 0; SideIndex < NumSides; SideIndex++)
{
const int32 CurrentIndex = SliceIndex * NumSides + SideIndex % NumSides + CapIndexStart;
const int32 NextSideIndex = SliceIndex * NumSides + (SideIndex + 1) % NumSides + CapIndexStart;
const int32 NextSliceIndex = (SliceIndex + 1) * NumSides + SideIndex % NumSides + CapIndexStart;
const int32 NextSliceAndSideIndex = (SliceIndex + 1) * NumSides + (SideIndex + 1) % NumSides + CapIndexStart;
Indices.Add(CurrentIndex);
Indices.Add(NextSliceIndex);
Indices.Add(NextSideIndex);
Indices.Add(NextSideIndex);
Indices.Add(NextSliceIndex);
Indices.Add(NextSliceAndSideIndex);
}
}
const uint32 Size = Indices.GetResourceDataSize();
const uint32 Stride = sizeof(uint16);
NumIndices = Indices.Num();
// Create index buffer. Fill buffer with initial data upon creation
FRHIResourceCreateInfo CreateInfo(&Indices);
IndexBufferRHI = RHICreateIndexBuffer(Stride, Size, BUF_Static,CreateInfo);
}
int32 GetIndexCount() const { return NumIndices; }
protected:
int32 NumIndices;
};
/**
* Vertex buffer for a cone. It holds zero'd out data since the actual math is done on the shader
*/
class FStencilConeVertexBuffer : public FVertexBuffer
{
public:
static const int32 NumVerts = FStencilConeIndexBuffer::NumSides * FStencilConeIndexBuffer::NumSlices * 2;
/**
* Initialize the RHI for this rendering resource
*/
void InitRHI() override
{
TResourceArray<FVector4, VERTEXBUFFER_ALIGNMENT> Verts;
Verts.Empty(NumVerts);
for (int32 s = 0; s < NumVerts; s++)
{
Verts.Add(FVector4(0, 0, 0, 0));
}
uint32 Size = Verts.GetResourceDataSize();
// Create vertex buffer. Fill buffer with initial data upon creation
FRHIResourceCreateInfo CreateInfo(&Verts);
VertexBufferRHI = RHICreateVertexBuffer(Size, BUF_Static, CreateInfo);
}
int32 GetVertexCount() const { return NumVerts; }
};
extern TGlobalResource<TStencilSphereVertexBuffer<18, 12, FVector4> > GStencilSphereVertexBuffer;
extern TGlobalResource<TStencilSphereVertexBuffer<18, 12, FVector> > GStencilSphereVectorBuffer;
extern TGlobalResource<TStencilSphereIndexBuffer<18, 12> > GStencilSphereIndexBuffer;
extern TGlobalResource<TStencilSphereVertexBuffer<4, 4, FVector4> > GLowPolyStencilSphereVertexBuffer;
extern TGlobalResource<TStencilSphereIndexBuffer<4, 4> > GLowPolyStencilSphereIndexBuffer;
extern TGlobalResource<FStencilConeVertexBuffer> GStencilConeVertexBuffer;
extern TGlobalResource<FStencilConeIndexBuffer> GStencilConeIndexBuffer;
}; //End StencilingGeometry