void TGPUSkinMorphVertexFactory<bExtraBoneInfluencesT>::AddVertexElements(DataType& InData, FVertexDeclarationElementList& OutElements)
{
// add the base gpu skin elements
TGPUSkinVertexFactory<bExtraBoneInfluencesT>::AddVertexElements(InData,OutElements);
// add the morph delta elements
OutElements.Add(FVertexFactory::AccessStreamComponent(InData.DeltaPositionComponent,9));
OutElements.Add(FVertexFactory::AccessStreamComponent(InData.DeltaTangentZComponent,10));
}
virtual void InitRHI() override
{
uint16 Stride = sizeof(FDistortionVertex);
FVertexDeclarationElementList Elements;
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, Position),VET_Float2,0, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TexR), VET_Float2, 1, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TexG), VET_Float2, 2, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TexB), VET_Float2, 3, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, VignetteFactor), VET_Float1, 4, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FDistortionVertex, TimewarpFactor), VET_Float1, 5, Stride));
VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
}
void FSlateVertexDeclaration::InitRHI()
{
FVertexDeclarationElementList Elements;
uint32 Stride = sizeof(FSlateVertex);
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, TexCoords), VET_Float4, 0, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, Position), VET_Float2, 1, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, ClipRect) + STRUCT_OFFSET(FSlateRotatedClipRectType, TopLeft), VET_Float2, 2, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, ClipRect) + STRUCT_OFFSET(FSlateRotatedClipRectType, ExtentX), VET_Float4, 3, Stride));
Elements.Add(FVertexElement(0, STRUCT_OFFSET(FSlateVertex, Color), VET_Color, 4, Stride));
VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
}
void TGPUSkinVertexFactory<bExtraBoneInfluencesT>::AddVertexElements(DataType& InData, FVertexDeclarationElementList& OutElements)
{
// position decls
OutElements.Add(AccessStreamComponent(InData.PositionComponent,0));
// tangent basis vector decls
OutElements.Add(AccessStreamComponent(InData.TangentBasisComponents[0],1));
OutElements.Add(AccessStreamComponent(InData.TangentBasisComponents[1],2));
// texture coordinate decls
if(InData.TextureCoordinates.Num())
{
const uint8 BaseTexCoordAttribute = 5;
for(int32 CoordinateIndex = 0;CoordinateIndex < InData.TextureCoordinates.Num();CoordinateIndex++)
{
OutElements.Add(AccessStreamComponent(
InData.TextureCoordinates[CoordinateIndex],
BaseTexCoordAttribute + CoordinateIndex
));
}
for(int32 CoordinateIndex = InData.TextureCoordinates.Num();CoordinateIndex < MAX_TEXCOORDS;CoordinateIndex++)
{
OutElements.Add(AccessStreamComponent(
InData.TextureCoordinates[InData.TextureCoordinates.Num() - 1],
BaseTexCoordAttribute + CoordinateIndex
));
}
}
// Account for the possibility that the mesh has no vertex colors
if( InData.ColorComponent.VertexBuffer )
{
OutElements.Add(AccessStreamComponent(InData.ColorComponent, 13));
}
else
{
//If the mesh has no color component, set the null color buffer on a new stream with a stride of 0.
//This wastes 4 bytes of bandwidth per vertex, but prevents having to compile out twice the number of vertex factories.
FVertexStreamComponent NullColorComponent(&GNullColorVertexBuffer, 0, 0, VET_Color);
OutElements.Add(AccessStreamComponent(NullColorComponent,13));
}
// bone indices decls
OutElements.Add(AccessStreamComponent(InData.BoneIndices,3));
// bone weights decls
OutElements.Add(AccessStreamComponent(InData.BoneWeights,4));
if (bExtraBoneInfluencesT)
{
// Extra bone indices & weights decls
OutElements.Add(AccessStreamComponent(InData.ExtraBoneIndices, 14));
OutElements.Add(AccessStreamComponent(InData.ExtraBoneWeights, 15));
}
}
void TGPUSkinAPEXClothVertexFactory<bExtraBoneInfluencesT>::AddVertexElements(DataType& InData, FVertexDeclarationElementList& OutElements)
{
// add the base gpu skin elements
TGPUSkinVertexFactory<bExtraBoneInfluencesT>::AddVertexElements(InData,OutElements);
// add the morph delta elements
// return;
if(InData.CoordNormalComponent.VertexBuffer)
{
OutElements.Add(FVertexFactory::AccessStreamComponent(InData.CoordPositionComponent,9));
OutElements.Add(FVertexFactory::AccessStreamComponent(InData.CoordNormalComponent,10));
OutElements.Add(FVertexFactory::AccessStreamComponent(InData.CoordTangentComponent,11));
OutElements.Add(FVertexFactory::AccessStreamComponent(InData.SimulIndicesComponent,12));
}
}
void FSlateVertexDeclaration::InitRHI()
{
FVertexDeclarationElementList Elements;
uint32 Stride = sizeof(FSlateVertex);
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,TexCoords),VET_Float4,0,Stride));
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,Position),VET_Short2,1,Stride));
bool bUseFloat16 =
#if SLATE_USE_FLOAT16
true;
#else
false;
#endif
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,ClipRect),bUseFloat16 ? VET_Half2 : VET_Float2,2,Stride));
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,ClipRect)+STRUCT_OFFSET(FSlateRotatedClipRectType,ExtentX),bUseFloat16 ? VET_Half4 : VET_Float4,3,Stride));
Elements.Add(FVertexElement(0,STRUCT_OFFSET(FSlateVertex,Color),VET_Color,4,Stride));
VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
}
void FLandscapeVertexFactoryMobile::InitRHI()
{
// list of declaration items
FVertexDeclarationElementList Elements;
// position decls
Elements.Add(AccessStreamComponent(MobileData.PositionComponent,0));
if (MobileData.LODHeightsComponent.Num())
{
const int32 BaseAttribute = 1;
for(int32 Index = 0;Index < MobileData.LODHeightsComponent.Num();Index++)
{
Elements.Add(AccessStreamComponent(MobileData.LODHeightsComponent[Index], BaseAttribute + Index));
}
}
// create the actual device decls
InitDeclaration(Elements);
}
virtual void InitRHI() override
{
FVertexDeclarationElementList Elements;
// Stream 0.
{
int32 Offset = 0;
// Sample.
Elements.Add(FVertexElement(0, Offset, VET_Color, 0, sizeof(FColor), /*bUseInstanceIndex=*/ true));
Offset += sizeof(FColor);
}
// Stream 1.
{
int32 Offset = 0;
// TexCoord.
Elements.Add(FVertexElement(1, Offset, VET_Float2, 1, sizeof(FVector2D), /*bUseInstanceIndex=*/ false));
Offset += sizeof(FVector2D);
}
VertexDeclarationRHI = RHICreateVertexDeclaration( Elements );
}
/**
* Patches the declaration so vertex stream offsets are unique. This is required for e.g. GeForce FX cards, which don't support redundant
* offsets in the declaration. We're unable to make that many vertex elements point to the same offset so the function moves redundant
* declarations to higher offsets, pointing to garbage data.
*/
static void PatchVertexStreamOffsetsToBeUnique( FVertexDeclarationElementList& Elements )
{
// check every vertex element
for ( int32 e = 0; e < Elements.Num(); e++ )
{
// check if there's an element that reads from the same offset
for ( int32 i = 0; i < Elements.Num(); i++ )
{
// but only in the same stream and if it's not the same element
if ( ( Elements[ i ].StreamIndex == Elements[ e ].StreamIndex ) && ( Elements[ i ].Offset == Elements[ e ].Offset ) && ( e != i ) )
{
// the id of the highest offset element is stored here (it doesn't need to be the last element in the declarator because the last element may belong to another StreamIndex
uint32 MaxOffsetID = i;
// find the highest offset element
for ( int32 j = 0; j < Elements.Num(); j++ )
{
if ( ( Elements[ j ].StreamIndex == Elements[ e ].StreamIndex ) && ( Elements[ MaxOffsetID ].Offset < Elements[ j ].Offset ) )
{
MaxOffsetID = j;
}
}
// get the size of the highest offset element, it's needed for the redundant element new offset
uint8 PreviousElementSize = GetVertexElementSize( Elements[ MaxOffsetID ].Type );
// prepare a new vertex element
FVertexElement VertElement;
VertElement.Offset = Elements[ MaxOffsetID ].Offset + PreviousElementSize;
VertElement.StreamIndex = Elements[ i ].StreamIndex;
VertElement.Type = Elements[ i ].Type;
VertElement.AttributeIndex = Elements[ i ].AttributeIndex;
VertElement.Stride = Elements[ i ].Stride;
VertElement.bUseInstanceIndex = Elements[i].bUseInstanceIndex;
// remove the old redundant element
Elements.RemoveAt( i );
// add a new element with "correct" offset
Elements.Add( VertElement );
// make sure that when the element has been removed its index is taken by the next element, so we must take care of it too
i = i == 0 ? 0 : i - 1;
}
}
}
}
virtual void FillDeclElements(FVertexDeclarationElementList& Elements, int32& Offset)
{
uint32 InitialStride = sizeof(float) * 2;
uint32 PerParticleStride = (sizeof(float) * 4) * NumVertsInInstanceBuffer;
/** The stream to read the texture coordinates from. */
check( Offset == 0 );
uint32 Stride = bInstanced ? InitialStride : InitialStride + PerParticleStride;
Elements.Add(FVertexElement(0, Offset, VET_Float2, 4, Stride, false));
Offset += sizeof(float) * 2;
/** The per-particle streams follow. */
if(bInstanced)
{
Offset = 0;
// update stride
Stride = PerParticleStride;
}
/** The stream to read the vertex position from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 0, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The stream to read the vertex old position from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 1, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The stream to read the vertex size/rot/subimage from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 2, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The stream to read the color from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 3, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The per-particle dynamic parameter stream */
// The -V519 disables a warning from PVS-Studio's static analyzer. It noticed that offset is assigned
// twice before being read. It is probably safer to leave the redundant assignments here to reduce
// the chance of an error being introduced if this code is modified.
Offset = 0; //-V519
Stride = sizeof(float) * 4;
Elements.Add(FVertexElement(bInstanced ? 2 : 1, Offset, VET_Float4, 5, Stride, bInstanced));
Offset += sizeof(float) * 4;
}
virtual void FillDeclElements(FVertexDeclarationElementList& Elements, int32& Offset)
{
uint16 Stride = sizeof(FParticleBeamTrailVertex);
/** The stream to read the vertex position from. */
Elements.Add(FVertexElement(0, Offset, VET_Float4, 0, Stride));
Offset += sizeof(float) * 4;
/** The stream to read the vertex old position from. */
Elements.Add(FVertexElement(0, Offset, VET_Float3, 1, Stride));
Offset += sizeof(float) * 4;
/** The stream to read the vertex size/rot/subimage from. */
Elements.Add(FVertexElement(0, Offset, VET_Float4, 2, Stride));
Offset += sizeof(float) * 4;
/** The stream to read the color from. */
Elements.Add(FVertexElement(0, Offset, VET_Float4, 4, Stride));
Offset += sizeof(float) * 4;
/** The stream to read the texture coordinates from. */
Elements.Add(FVertexElement(0, Offset, VET_Float4, 3, Stride));
Offset += sizeof(float) * 4;
/** Dynamic parameters come from a second stream */
Elements.Add(FVertexElement(1, 0, VET_Float4, 5, sizeof(FVector4)));
}
virtual void FillDeclElements(FVertexDeclarationElementList& Elements, int32& Offset)
{
uint32 InitialStride = sizeof(float) * 2;
uint32 PerParticleStride = (sizeof(float) * 4) * 4;
/** The stream to read the texture coordinates from. */
check( Offset == 0 );
uint32 Stride = bInstanced ? InitialStride : InitialStride + PerParticleStride;
Elements.Add(FVertexElement(0, Offset, VET_Float2, 4, Stride, false));
Offset += sizeof(float) * 2;
/** The per-particle streams follow. */
if(bInstanced)
{
Offset = 0;
// update stride
Stride = PerParticleStride;
}
/** The stream to read the vertex position from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 0, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The stream to read the vertex old position from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 1, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The stream to read the vertex size/rot/subimage from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 2, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The stream to read the color from. */
Elements.Add(FVertexElement(bInstanced ? 1 : 0, Offset, VET_Float4, 3, Stride, bInstanced));
Offset += sizeof(float) * 4;
/** The per-particle dynamic parameter stream */
Offset = 0;
Stride = sizeof(float) * 4;
Elements.Add(FVertexElement(bInstanced ? 2 : 1, Offset, VET_Float4, 5, Stride, bInstanced));
Offset += sizeof(float) * 4;
}
virtual void InitRHI() override
{
FVertexDeclarationElementList Elements;
Elements.Add(FVertexElement(0, 0, VET_Float2, 0, sizeof(FVector2D)));
VertexDeclarationRHI = RHICreateVertexDeclaration(Elements);
}
void FMeshParticleVertexFactory::InitRHI()
{
FVertexDeclarationElementList Elements;
const bool bInstanced = GetFeatureLevel() >= ERHIFeatureLevel::SM4;
if (Data.bInitialized)
{
if(bInstanced)
{
// Stream 0 - Instance data
{
checkf(DynamicVertexStride != -1, TEXT("FMeshParticleVertexFactory does not have a valid DynamicVertexStride - likely an empty one was made, but SetStrides was not called"));
FVertexStream VertexStream;
VertexStream.VertexBuffer = NULL;
VertexStream.Stride = 0;
VertexStream.Offset = 0;
Streams.Add(VertexStream);
// @todo metal: this will need a valid stride when we get to instanced meshes!
Elements.Add(FVertexElement(0, Data.TransformComponent[0].Offset, Data.TransformComponent[0].Type, 8, DynamicVertexStride, Data.TransformComponent[0].bUseInstanceIndex));
Elements.Add(FVertexElement(0, Data.TransformComponent[1].Offset, Data.TransformComponent[1].Type, 9, DynamicVertexStride, Data.TransformComponent[1].bUseInstanceIndex));
Elements.Add(FVertexElement(0, Data.TransformComponent[2].Offset, Data.TransformComponent[2].Type, 10, DynamicVertexStride, Data.TransformComponent[2].bUseInstanceIndex));
Elements.Add(FVertexElement(0, Data.SubUVs.Offset, Data.SubUVs.Type, 11, DynamicVertexStride, Data.SubUVs.bUseInstanceIndex));
Elements.Add(FVertexElement(0, Data.SubUVLerpAndRelTime.Offset, Data.SubUVLerpAndRelTime.Type, 12, DynamicVertexStride, Data.SubUVLerpAndRelTime.bUseInstanceIndex));
Elements.Add(FVertexElement(0, Data.ParticleColorComponent.Offset, Data.ParticleColorComponent.Type, 14, DynamicVertexStride, Data.ParticleColorComponent.bUseInstanceIndex));
Elements.Add(FVertexElement(0, Data.VelocityComponent.Offset, Data.VelocityComponent.Type, 15, DynamicVertexStride, Data.VelocityComponent.bUseInstanceIndex));
}
// Stream 1 - Dynamic parameter
{
checkf(DynamicParameterVertexStride != -1, TEXT("FMeshParticleVertexFactory does not have a valid DynamicParameterVertexStride - likely an empty one was made, but SetStrides was not called"));
FVertexStream VertexStream;
VertexStream.VertexBuffer = NULL;
VertexStream.Stride = 0;
VertexStream.Offset = 0;
Streams.Add(VertexStream);
Elements.Add(FVertexElement(1, 0, VET_Float4, 13, DynamicParameterVertexStride, true));
}
}
if(Data.PositionComponent.VertexBuffer != NULL)
{
Elements.Add(AccessStreamComponent(Data.PositionComponent,0));
}
// only tangent,normal are used by the stream. the binormal is derived in the shader
uint8 TangentBasisAttributes[2] = { 1, 2 };
for(int32 AxisIndex = 0;AxisIndex < 2;AxisIndex++)
{
if(Data.TangentBasisComponents[AxisIndex].VertexBuffer != NULL)
{
Elements.Add(AccessStreamComponent(Data.TangentBasisComponents[AxisIndex],TangentBasisAttributes[AxisIndex]));
}
}
// Vertex color
if(Data.VertexColorComponent.VertexBuffer != NULL)
{
Elements.Add(AccessStreamComponent(Data.VertexColorComponent,3));
}
else
{
//If the mesh has no color component, set the null color buffer on a new stream with a stride of 0.
//This wastes 4 bytes of bandwidth per vertex, but prevents having to compile out twice the number of vertex factories.
FVertexStreamComponent NullColorComponent(&GNullColorVertexBuffer, 0, 0, VET_Color);
Elements.Add(AccessStreamComponent(NullColorComponent,3));
}
if(Data.TextureCoordinates.Num())
{
const int32 BaseTexCoordAttribute = 4;
for(int32 CoordinateIndex = 0;CoordinateIndex < Data.TextureCoordinates.Num();CoordinateIndex++)
{
Elements.Add(AccessStreamComponent(
Data.TextureCoordinates[CoordinateIndex],
BaseTexCoordAttribute + CoordinateIndex
));
}
for(int32 CoordinateIndex = Data.TextureCoordinates.Num();CoordinateIndex < MAX_TEXCOORDS;CoordinateIndex++)
{
Elements.Add(AccessStreamComponent(
Data.TextureCoordinates[Data.TextureCoordinates.Num() - 1],
BaseTexCoordAttribute + CoordinateIndex
));
}
}
if(Streams.Num() > 0)
{
InitDeclaration(Elements,Data);
check(IsValidRef(GetDeclaration()));
}
}
}
