virtual void InitRHI() override
{
#if ENGINE_MAJOR_VERSION >= 4 && ENGINE_MINOR_VERSION >= 3
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), BOSize * sizeof(int32), BUF_AnyDynamic, CreateInfo);
#else
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), BOSize * sizeof(int32), NULL, BUF_AnyDynamic);
#endif
}
virtual void InitRHI() override
{
#if ENGINE_MAJOR_VERSION >= 4 && ENGINE_MINOR_VERSION >= 3
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), Indices.Num() * sizeof(int32), BUF_Static, CreateInfo);
#else
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), Indices.Num() * sizeof(int32), NULL, BUF_Static);
#endif
// Write the indices to the index buffer.
void* Buffer = RHILockIndexBuffer(IndexBufferRHI, 0, Indices.Num() * sizeof(int32), RLM_WriteOnly);
FMemory::Memcpy(Buffer, Indices.GetData(), Indices.Num() * sizeof(int32));
RHIUnlockIndexBuffer(IndexBufferRHI);
}
void FStreetMapIndexBuffer::InitRHI()
{
const int IndexCount = FMath::Max( Indices16.Num(), Indices32.Num() );
if( IndexCount > 0 )
{
const bool b32BitIndices = Indices32.Num() > Indices16.Num();
const uint8 IndexSize = b32BitIndices ? sizeof( Indices32[ 0 ] ) : sizeof( Indices16[ 0 ] );
const void* IndexSourceData;
if( b32BitIndices )
{
IndexSourceData = Indices32.GetData();
}
else
{
IndexSourceData = Indices16.GetData();
}
// Allocate our index buffer and load it with data
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer( IndexSize, IndexCount * IndexSize, BUF_Static, CreateInfo );
void* IndexBufferData = RHILockIndexBuffer( IndexBufferRHI, 0, IndexCount * IndexSize, RLM_WriteOnly );
FMemory::Memcpy( IndexBufferData, IndexSourceData, IndexCount * IndexSize );
RHIUnlockIndexBuffer( IndexBufferRHI );
}
}
void FTesselatedScreenRectangleIndexBuffer::InitRHI()
{
TResourceArray<uint16, INDEXBUFFER_ALIGNMENT> IndexBuffer;
uint32 NumIndices = NumPrimitives() * 3;
IndexBuffer.AddUninitialized(NumIndices);
uint16* Out = (uint16*)IndexBuffer.GetData();
for(uint32 y = 0; y < Height; ++y)
{
for(uint32 x = 0; x < Width; ++x)
{
// left top to bottom right in reading order
uint16 Index00 = x + y * (Width + 1);
uint16 Index10 = Index00 + 1;
uint16 Index01 = Index00 + (Width + 1);
uint16 Index11 = Index01 + 1;
// todo: diagonal can be flipped on parts of the screen
// triangle A
*Out++ = Index00; *Out++ = Index01; *Out++ = Index10;
// triangle B
*Out++ = Index11; *Out++ = Index10; *Out++ = Index01;
}
}
// Create index buffer. Fill buffer with initial data upon creation
FRHIResourceCreateInfo CreateInfo(&IndexBuffer);
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint16), IndexBuffer.GetResourceDataSize(), BUF_Static, CreateInfo);
}
virtual void InitRHI() override
{
const uint32 Size = sizeof(uint16) * 6 * 8;
const uint32 Stride = sizeof(uint16);
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer( Stride, Size, BUF_Static, CreateInfo );
uint16* Indices = (uint16*)RHILockIndexBuffer( IndexBufferRHI, 0, Size, RLM_WriteOnly );
for (uint32 SpriteIndex = 0; SpriteIndex < 8; ++SpriteIndex)
{
#if PLATFORM_MAC // Avoid a driver bug on OSX/NV cards that causes driver to generate an unwound index buffer
Indices[SpriteIndex*6 + 0] = SpriteIndex*6 + 0;
Indices[SpriteIndex*6 + 1] = SpriteIndex*6 + 1;
Indices[SpriteIndex*6 + 2] = SpriteIndex*6 + 2;
Indices[SpriteIndex*6 + 3] = SpriteIndex*6 + 3;
Indices[SpriteIndex*6 + 4] = SpriteIndex*6 + 4;
Indices[SpriteIndex*6 + 5] = SpriteIndex*6 + 5;
#else
Indices[SpriteIndex*6 + 0] = SpriteIndex*4 + 0;
Indices[SpriteIndex*6 + 1] = SpriteIndex*4 + 3;
Indices[SpriteIndex*6 + 2] = SpriteIndex*4 + 2;
Indices[SpriteIndex*6 + 3] = SpriteIndex*4 + 0;
Indices[SpriteIndex*6 + 4] = SpriteIndex*4 + 1;
Indices[SpriteIndex*6 + 5] = SpriteIndex*4 + 3;
#endif
}
RHIUnlockIndexBuffer( IndexBufferRHI );
}
void FRawIndexBuffer16or32::InitRHI()
{
uint32 Size = Indices.Num() * sizeof(uint32);
if( Size > 0 )
{
// Create the index buffer.
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint32),Size,BUF_Static,CreateInfo);
// Initialize the buffer.
void* Buffer = RHILockIndexBuffer(IndexBufferRHI, 0, Size, RLM_WriteOnly);
FMemory::Memcpy(Buffer,Indices.GetData(),Size);
RHIUnlockIndexBuffer(IndexBufferRHI);
}
// BSP sample debugging requires CPU access to index buffers
#if !ALLOW_LIGHTMAP_SAMPLE_DEBUGGING
// Undo/redo can destroy and recreate the render resources for UModels without rebuilding the
// buffers, so the indices need to be saved when in the editor.
if (!GIsEditor && !IsRunningCommandlet())
{
Indices.Empty();
}
#endif
}
virtual void InitRHI() override
{
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), Indices.Num() * sizeof(int32), BUF_Static, CreateInfo);
// Write the indices to the index buffer.
void* Buffer = RHILockIndexBuffer(IndexBufferRHI, 0, Indices.Num() * sizeof(int32), RLM_WriteOnly);
FMemory::Memcpy(Buffer, Indices.GetData(), Indices.Num() * sizeof(int32));
RHIUnlockIndexBuffer(IndexBufferRHI);
}
virtual void InitRHI()
{
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), Indices.Num() * sizeof(int32), NULL, BUF_Static);
// Write the indices to the index buffer.
void* Buffer = RHILockIndexBuffer(IndexBufferRHI, 0, Indices.Num() * sizeof(int32), RLM_WriteOnly);
FMemory::Memcpy(Buffer, Indices.GetTypedData(), Indices.Num() * sizeof(int32));
RHIUnlockIndexBuffer(IndexBufferRHI);
}
void InitRHI()
{
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint16), Indices.Num() * sizeof(uint16), BUF_Static, CreateInfo);
// Copy the index data into the index buffer.
void* Buffer = RHILockIndexBuffer(IndexBufferRHI, 0, Indices.Num() * sizeof(uint16), RLM_WriteOnly);
FMemory::Memcpy(Buffer, Indices.GetData(), Indices.Num() * sizeof(uint16));
RHIUnlockIndexBuffer(IndexBufferRHI);
}
void FRawStaticIndexBuffer::InitRHI()
{
uint32 IndexStride = b32Bit ? sizeof(uint32) : sizeof(uint16);
uint32 SizeInBytes = IndexStorage.Num();
if (SizeInBytes > 0)
{
// Create the index buffer.
FRHIResourceCreateInfo CreateInfo(&IndexStorage);
IndexBufferRHI = RHICreateIndexBuffer(IndexStride,SizeInBytes,BUF_Static,CreateInfo);
}
}
/** Initializes the index buffers RHI resource. */
void FSlateElementIndexBuffer::InitDynamicRHI()
{
checkSlow( IsInRenderingThread() );
check( MinBufferSize > 0 );
BufferSize = MinBufferSize;
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer( sizeof(SlateIndex), MinBufferSize, BUF_Dynamic, CreateInfo );
check( IsValidRef(IndexBufferRHI) );
}
/** Initializes the index buffers RHI resource. */
void FSlateElementIndexBuffer::InitDynamicRHI()
{
check( IsInRenderingThread() );
if( BufferSize == 0 )
{
BufferSize = 200 * sizeof(SlateIndex);
}
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer( sizeof(SlateIndex), BufferSize, BUF_Dynamic, CreateInfo );
check( IsValidRef(IndexBufferRHI) );
}
/** Resizes the buffer to the passed in size. Preserves internal data */
void FSlateElementIndexBuffer::ResizeBuffer( uint32 NewSizeBytes )
{
check( IsInRenderingThread() );
if( NewSizeBytes != 0 && NewSizeBytes != BufferSize)
{
IndexBufferRHI.SafeRelease();
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer( sizeof(SlateIndex), NewSizeBytes, BUF_Dynamic, CreateInfo );
check(IsValidRef(IndexBufferRHI));
BufferSize = NewSizeBytes;
}
}
/** Initialize the RHI for this rendering resource */
void InitRHI() override
{
// Indices 0 - 5 are used for rendering a quad. Indices 6 - 8 are used for triangle optimization.
const uint16 Indices[] = { 0, 1, 2, 2, 1, 3, 0, 4, 5 };
TResourceArray<uint16, INDEXBUFFER_ALIGNMENT> IndexBuffer;
uint32 InternalNumIndices = ARRAY_COUNT(Indices);
IndexBuffer.AddUninitialized(InternalNumIndices);
FMemory::Memcpy(IndexBuffer.GetData(), Indices, InternalNumIndices * sizeof(uint16));
// Create index buffer. Fill buffer with initial data upon creation
FRHIResourceCreateInfo CreateInfo(&IndexBuffer);
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint16), IndexBuffer.GetResourceDataSize(), BUF_Static, CreateInfo);
}
/**
* Initialize the RHI for this rendering resource
*/
void InitRHI() override
{
TResourceArray<uint16, INDEXBUFFER_ALIGNMENT> Indices;
NumIndices = ARRAY_COUNT(GCubeIndices);
Indices.AddUninitialized(NumIndices);
FMemory::Memcpy(Indices.GetData(), GCubeIndices, NumIndices * sizeof(uint16));
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);
}
void FRawIndexBuffer::InitRHI()
{
uint32 Size = Indices.Num() * sizeof(uint16);
if( Size > 0 )
{
// Create the index buffer.
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint16),Size,BUF_Static,CreateInfo);
// Initialize the buffer.
void* Buffer = RHILockIndexBuffer(IndexBufferRHI, 0, Size, RLM_WriteOnly);
FMemory::Memcpy(Buffer,Indices.GetData(),Size);
RHIUnlockIndexBuffer(IndexBufferRHI);
}
}
/** Resizes the buffer to the passed in size. Preserves internal data */
void FSlateElementIndexBuffer::ResizeBuffer( int32 NewSizeBytes )
{
checkSlow( IsInRenderingThread() );
int32 FinalSize = FMath::Max( NewSizeBytes, MinBufferSize );
if( FinalSize != 0 && FinalSize != BufferSize )
{
IndexBufferRHI.SafeRelease();
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer( sizeof(SlateIndex), FinalSize, BUF_Dynamic, CreateInfo );
check(IsValidRef(IndexBufferRHI));
BufferSize = FinalSize;
}
}
//
// IndexBuffer
//
void FSsPartsIndexBuffer::InitRHI()
{
if(0 < NumIndices)
{
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint32), NumIndices * sizeof(uint32), BUF_Dynamic, CreateInfo);
void* IndicesPtr = RHILockIndexBuffer(IndexBufferRHI, 0, NumIndices * sizeof(uint32), RLM_WriteOnly);
for(uint32 i = 0; i < NumIndices/6; ++i)
{
((uint32*)IndicesPtr)[i*6+0] = i*4+0;
((uint32*)IndicesPtr)[i*6+1] = i*4+1;
((uint32*)IndicesPtr)[i*6+2] = i*4+3;
((uint32*)IndicesPtr)[i*6+3] = i*4+0;
((uint32*)IndicesPtr)[i*6+4] = i*4+3;
((uint32*)IndicesPtr)[i*6+5] = i*4+2;
}
RHIUnlockIndexBuffer(IndexBufferRHI);
}
}
/**
* Creates an index buffer for drawing an individual sprite.
*/
void FParticleIndexBuffer::InitRHI()
{
// Instanced path needs only MAX_PARTICLES_PER_INSTANCE,
// but using the maximum needed for the non-instanced path
// in prep for future flipping of both instanced and non-instanced at runtime.
const uint32 MaxParticles = 65536 / 4;
const uint32 Size = sizeof(uint16) * 6 * MaxParticles;
const uint32 Stride = sizeof(uint16);
IndexBufferRHI = RHICreateIndexBuffer( Stride, Size, NULL, BUF_Static );
uint16* Indices = (uint16*)RHILockIndexBuffer( IndexBufferRHI, 0, Size, RLM_WriteOnly );
for (uint32 SpriteIndex = 0; SpriteIndex < MaxParticles; ++SpriteIndex)
{
Indices[SpriteIndex*6 + 0] = SpriteIndex*4 + 0;
Indices[SpriteIndex*6 + 1] = SpriteIndex*4 + 2;
Indices[SpriteIndex*6 + 2] = SpriteIndex*4 + 3;
Indices[SpriteIndex*6 + 3] = SpriteIndex*4 + 0;
Indices[SpriteIndex*6 + 4] = SpriteIndex*4 + 1;
Indices[SpriteIndex*6 + 5] = SpriteIndex*4 + 2;
}
RHIUnlockIndexBuffer( IndexBufferRHI );
}
// IndexBuffer
void FSsPlaneIndexBuffer::InitRHI()
{
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(uint32), NumIndices * sizeof(uint32), BUF_Dynamic, CreateInfo);
}
virtual void InitRHI() override
{
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), Indices.Num() * sizeof(int32), BUF_Dynamic, CreateInfo);
UpdateRenderData();
}
virtual void InitRHI() override
{
FRHIResourceCreateInfo CreateInfo;
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), NumIndices * sizeof(int32), BUF_Dynamic, CreateInfo);
}
virtual void InitRHI()
{
IndexBufferRHI = RHICreateIndexBuffer(sizeof(int32), NumIndices * sizeof(int32), NULL, BUF_Dynamic);
}
