void* GLIndexBufferCore::lockImpl(UINT32 offset, UINT32 length, GpuLockOptions options)
{
GLenum access = 0;
if(mIsLocked)
{
BS_EXCEPT(InternalErrorException,
"Invalid attempt to lock an index buffer that has already been locked");
}
#if BS_PROFILING_ENABLED
if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
{
BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_IndexBuffer);
}
if (options == GBL_READ_WRITE || options == GBL_WRITE_ONLY || options == GBL_WRITE_ONLY_DISCARD || options == GBL_WRITE_ONLY_NO_OVERWRITE)
{
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_IndexBuffer);
}
#endif
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mBufferId);
if ((options == GBL_WRITE_ONLY) || (options == GBL_WRITE_ONLY_NO_OVERWRITE) || (options == GBL_WRITE_ONLY_DISCARD))
{
access = GL_MAP_WRITE_BIT;
if(options == GBL_WRITE_ONLY_DISCARD)
access |= GL_MAP_INVALIDATE_BUFFER_BIT;
else if(options == GBL_WRITE_ONLY_NO_OVERWRITE)
access |= GL_MAP_UNSYNCHRONIZED_BIT;
}
else if (options == GBL_READ_ONLY)
access = GL_MAP_READ_BIT;
else
access = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
void* pBuffer = nullptr;
if (length > 0)
{
pBuffer = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, offset, length, access);
if (pBuffer == nullptr)
{
BS_EXCEPT(InternalErrorException, "Index Buffer: Out of memory");
}
mZeroLocked = false;
}
else
mZeroLocked = true;
void* retPtr = static_cast<void*>(static_cast<unsigned char*>(pBuffer));
mIsLocked = true;
return retPtr;
}
PixelData D3D11TextureCore::lockImpl(GpuLockOptions options, UINT32 mipLevel, UINT32 face)
{
if (mProperties.getMultisampleCount() > 1)
BS_EXCEPT(InvalidStateException, "Multisampled textures cannot be accessed from the CPU directly.");
#if BS_PROFILING_ENABLED
if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
{
BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_Texture);
}
if (options == GBL_READ_WRITE || options == GBL_WRITE_ONLY || options == GBL_WRITE_ONLY_DISCARD || options == GBL_WRITE_ONLY_NO_OVERWRITE)
{
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_Texture);
}
#endif
UINT32 mipWidth = std::max(1u, mProperties.getWidth() >> mipLevel);
UINT32 mipHeight = std::max(1u, mProperties.getHeight() >> mipLevel);
UINT32 mipDepth = std::max(1u, mProperties.getDepth() >> mipLevel);
PixelData lockedArea(mipWidth, mipHeight, mipDepth, mProperties.getFormat());
D3D11_MAP flags = D3D11Mappings::getLockOptions(options);
UINT32 rowPitch, slicePitch;
if(flags == D3D11_MAP_READ || flags == D3D11_MAP_READ_WRITE)
{
UINT8* data = (UINT8*)mapstagingbuffer(flags, face, mipLevel, rowPitch, slicePitch);
lockedArea.setExternalBuffer(data);
lockedArea.setRowPitch(rowPitch);
lockedArea.setSlicePitch(slicePitch);
mLockedForReading = true;
}
else
{
if (mProperties.getUsage() == TU_DYNAMIC)
{
UINT8* data = (UINT8*)map(mTex, flags, face, mipLevel, rowPitch, slicePitch);
lockedArea.setExternalBuffer(data);
lockedArea.setRowPitch(rowPitch);
lockedArea.setSlicePitch(slicePitch);
}
else
lockedArea.setExternalBuffer((UINT8*)mapstaticbuffer(lockedArea, mipLevel, face));
mLockedForReading = false;
}
return lockedArea;
}
void* GLGpuBufferCore::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
{
#if BS_PROFILING_ENABLED
if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
{
BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_GpuBuffer);
}
if (options == GBL_READ_WRITE || options == GBL_WRITE_ONLY || options == GBL_WRITE_ONLY_DISCARD || options == GBL_WRITE_ONLY_NO_OVERWRITE)
{
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_GpuBuffer);
}
#endif
return nullptr;
}
void GLGpuBufferCore::initialize()
{
LOGWRN("Generic buffers are not supported in OpenGL. Creating a dummy buffer. All operations on it will either be no-op or return a nullptr.");
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuBuffer);
GpuBufferCore::initialize();
}
GpuBufferView::~GpuBufferView()
{
SAFE_RELEASE(mSRV);
SAFE_RELEASE(mUAV);
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_ResourceView);
}
GLGpuBufferCore::~GLGpuBufferCore()
{
glDeleteTextures(1, &mTextureID);
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuBuffer);
clearBufferViews();
}
void D3D11BlendState::createInternal()
{
D3D11_BLEND_DESC blendStateDesc;
ZeroMemory(&blendStateDesc, sizeof(D3D11_BLEND_DESC));
blendStateDesc.AlphaToCoverageEnable = mProperties.getAlphaToCoverageEnabled();
blendStateDesc.IndependentBlendEnable = mProperties.getIndependantBlendEnable();
for(UINT32 i = 0; i < BS_MAX_MULTIPLE_RENDER_TARGETS; i++)
{
blendStateDesc.RenderTarget[i].BlendEnable = mProperties.getBlendEnabled(i);
blendStateDesc.RenderTarget[i].BlendOp = D3D11Mappings::get(mProperties.getBlendOperation(i));
blendStateDesc.RenderTarget[i].BlendOpAlpha = D3D11Mappings::get(mProperties.getAlphaBlendOperation(i));
blendStateDesc.RenderTarget[i].DestBlend = D3D11Mappings::get(mProperties.getDstBlend(i));
blendStateDesc.RenderTarget[i].DestBlendAlpha = D3D11Mappings::get(mProperties.getAlphaDstBlend(i));
blendStateDesc.RenderTarget[i].RenderTargetWriteMask = 0xf & (mProperties.getRenderTargetWriteMask(i)); // Mask out all but last 4 bits
blendStateDesc.RenderTarget[i].SrcBlend = D3D11Mappings::get(mProperties.getSrcBlend(i));
blendStateDesc.RenderTarget[i].SrcBlendAlpha = D3D11Mappings::get(mProperties.getAlphaSrcBlend(i));
}
D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPI::instancePtr());
D3D11Device& device = rs->getPrimaryDevice();
HRESULT hr = device.getD3D11Device()->CreateBlendState(&blendStateDesc, &mBlendState);
if(FAILED(hr) || device.hasError())
{
String errorDescription = device.getErrorDescription();
BS_EXCEPT(RenderingAPIException, "Cannot create blend state.\nError Description:" + errorDescription);
}
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_BlendState);
BlendState::createInternal();
}
VulkanGpuParamBlockBuffer::~VulkanGpuParamBlockBuffer()
{
if(mBuffer != nullptr)
bs_delete(mBuffer);
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuParamBuffer);
}
D3D11TimerQuery::D3D11TimerQuery()
:mFinalized(false), mContext(nullptr), mBeginQuery(nullptr),
mEndQuery(nullptr), mDisjointQuery(nullptr), mTimeDelta(0.0f), mQueryEndCalled(false)
{
D3D11RenderAPI* rs = static_cast<D3D11RenderAPI*>(RenderAPICore::instancePtr());
D3D11Device& device = rs->getPrimaryDevice();
D3D11_QUERY_DESC queryDesc;
queryDesc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT;
queryDesc.MiscFlags = 0;
HRESULT hr = device.getD3D11Device()->CreateQuery(&queryDesc, &mDisjointQuery);
if(hr != S_OK)
{
BS_EXCEPT(RenderingAPIException, "Failed to create a timer query.");
}
queryDesc.Query = D3D11_QUERY_TIMESTAMP;
hr = device.getD3D11Device()->CreateQuery(&queryDesc, &mBeginQuery);
if(hr != S_OK)
{
BS_EXCEPT(RenderingAPIException, "Failed to create a timer query.");
}
hr = device.getD3D11Device()->CreateQuery(&queryDesc, &mEndQuery);
if(hr != S_OK)
{
BS_EXCEPT(RenderingAPIException, "Failed to create a timer query.");
}
mContext = device.getImmediateContext();
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query);
}
void VulkanTexture::writeDataImpl(const PixelData& src, UINT32 mipLevel, UINT32 face, bool discardWholeBuffer,
UINT32 queueIdx)
{
if (mProperties.getNumSamples() > 1)
{
LOGERR("Multisampled textures cannot be accessed from the CPU directly.");
return;
}
mipLevel = Math::clamp(mipLevel, (UINT32)mipLevel, mProperties.getNumMipmaps());
face = Math::clamp(face, (UINT32)0, mProperties.getNumFaces() - 1);
if (face > 0 && mProperties.getTextureType() == TEX_TYPE_3D)
{
LOGERR("3D texture arrays are not supported.");
return;
}
// Write to every device
for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
{
if (mImages[i] == nullptr)
continue;
PixelData myData = lock(discardWholeBuffer ? GBL_WRITE_ONLY_DISCARD : GBL_WRITE_ONLY_DISCARD_RANGE,
mipLevel, face, i, queueIdx);
PixelUtil::bulkPixelConversion(src, myData);
unlock();
}
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_Texture);
}
D3D11IndexBuffer::~D3D11IndexBuffer()
{
if (mBuffer != nullptr)
bs_delete(mBuffer);
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_IndexBuffer);
}
void D3D11IndexBuffer::initialize()
{
mBuffer = bs_new<D3D11HardwareBuffer>(D3D11HardwareBuffer::BT_INDEX, mUsage, 1, mSize, std::ref(mDevice), false);
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_IndexBuffer);
IndexBuffer::initialize();
}
GLOcclusionQuery::~GLOcclusionQuery()
{
glDeleteQueries(1, &mQueryObj);
BS_CHECK_GL_ERROR();
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
}
D3D11OcclusionQuery::~D3D11OcclusionQuery()
{
if (mQuery != nullptr)
mQuery->Release();
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
}
void* D3D11IndexBuffer::map(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx)
{
#if BS_PROFILING_ENABLED
if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
{
BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_IndexBuffer);
}
if (options == GBL_READ_WRITE || options == GBL_WRITE_ONLY || options == GBL_WRITE_ONLY_DISCARD || options == GBL_WRITE_ONLY_NO_OVERWRITE)
{
BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_IndexBuffer);
}
#endif
return mBuffer->lock(offset, length, options);
}
D3D9TimerQuery::D3D9TimerQuery()
:mFinalized(false), mBeginQuery(nullptr), mFreqQuery(nullptr), mQueryIssued(false),
mEndQuery(nullptr), mDisjointQuery(nullptr), mTimeDelta(0.0f), mDevice(nullptr)
{
createQuery();
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query);
}
D3D11EventQuery::~D3D11EventQuery()
{
if(mQuery != nullptr)
{
mQuery->Release();
}
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
}
GLFrameBufferObject::GLFrameBufferObject()
{
glGenFramebuffers(1, &mFB);
for(UINT32 x = 0; x < BS_MAX_MULTIPLE_RENDER_TARGETS; ++x)
mColor[x].buffer = nullptr;
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_FrameBufferObject);
}
GLTimerQuery::~GLTimerQuery()
{
GLuint queries[2];
queries[0] = mQueryStartObj;
queries[1] = mQueryEndObj;
glDeleteQueries(2, queries);
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
}
GLOcclusionQuery::GLOcclusionQuery(bool binary, UINT32 deviceIdx)
:OcclusionQuery(binary), mQueryObj(0), mFinalized(false), mEndIssued(false), mNumSamples(0)
{
assert(deviceIdx == 0 && "Multiple GPUs not supported natively on OpenGL.");
glGenQueries(1, &mQueryObj);
BS_CHECK_GL_ERROR();
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query);
}
VulkanGpuProgram::~VulkanGpuProgram()
{
for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
{
if (mModules[i] != nullptr)
mModules[i]->destroy();
}
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuProgram);
}
void VulkanGpuParamBlockBuffer::initialize()
{
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuParamBuffer);
GpuBufferUsage usage = mUsage == GPBU_STATIC ? GBU_STATIC : GBU_DYNAMIC;
mBuffer = bs_new<VulkanHardwareBuffer>(VulkanHardwareBuffer::BT_UNIFORM, BF_UNKNOWN, usage, mSize, mDeviceMask);
GpuParamBlockBuffer::initialize();
}
GLTimerQuery::GLTimerQuery()
:mQueryStartObj(0), mQueryEndObj(0), mFinalized(false), mEndIssued(false), mTimeDelta(0.0f)
{
GLuint queries[2];
glGenQueries(2, queries);
mQueryStartObj = queries[0];
mQueryEndObj = queries[1];
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query);
}
GLSLGpuProgram::~GLSLGpuProgram()
{
if (mIsCompiled && mGLHandle != 0)
{
glDeleteProgram(mGLHandle);
BS_CHECK_GL_ERROR();
mGLHandle = 0;
}
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuProgram);
}
D3D11TimerQuery::~D3D11TimerQuery()
{
if(mBeginQuery != nullptr)
mBeginQuery->Release();
if(mEndQuery != nullptr)
mEndQuery->Release();
if(mDisjointQuery != nullptr)
mDisjointQuery->Release();
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
}
VulkanGraphicsPipelineState::~VulkanGraphicsPipelineState()
{
for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
{
if (mPerDeviceData[i].device == nullptr)
continue;
for(auto& entry : mPerDeviceData[i].pipelines)
entry.second->destroy();
}
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_PipelineState);
}
void VulkanTexture::readDataImpl(PixelData& dest, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx, UINT32 queueIdx)
{
if (mProperties.getNumSamples() > 1)
{
LOGERR("Multisampled textures cannot be accessed from the CPU directly.");
return;
}
PixelData myData = lock(GBL_READ_ONLY, mipLevel, face, deviceIdx, queueIdx);
PixelUtil::bulkPixelConversion(myData, dest);
unlock();
BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_Texture);
}
VulkanTexture::~VulkanTexture()
{
for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
{
if (mImages[i] == nullptr)
return;
mImages[i]->destroy();
}
assert(mStagingBuffer == nullptr);
BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Texture);
}
void GLGpuBufferCore::initialize()
{
// Create buffer
const auto& props = getProperties();
UINT32 size = props.getElementCount() * props.getElementSize();
mBuffer.initialize(GL_TEXTURE_BUFFER, size, props.getUsage());
// Create texture
glGenTextures(1, &mTextureID);
glBindTexture(GL_TEXTURE_BUFFER, mTextureID);
glTexBuffer(GL_TEXTURE_BUFFER, mFormat, mBuffer.getGLBufferId());
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuBuffer);
GpuBufferCore::initialize();
}
void GLIndexBufferCore::initialize()
{
glGenBuffers(1, &mBufferId );
if (!mBufferId)
{
BS_EXCEPT(InternalErrorException, "Cannot create GL index buffer");
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mBufferId);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, mSizeInBytes, NULL,
GLHardwareBufferCoreManager::getGLUsage(mUsage));
BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_IndexBuffer);
IndexBufferCore::initialize();
}
