bool WrappedOpenGL::Serialise_glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
{
SERIALISE_ELEMENT(GLenum, sh, shadertype);
SERIALISE_ELEMENT(uint32_t, Count, count);
SERIALISE_ELEMENT_ARR(uint32_t, Idxs, indices, Count);
if(m_State <= EXECUTING)
m_Real.glUniformSubroutinesuiv(sh, Count, Idxs);
SAFE_DELETE_ARRAY(Idxs);
return true;
}
bool WrappedOpenGL::Serialise_glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
{
SERIALISE_ELEMENT(uint32_t, idx, first);
SERIALISE_ELEMENT(uint32_t, cnt, count);
SERIALISE_ELEMENT_ARR(GLdouble, ranges, v, cnt * 2);
if(m_State <= EXECUTING)
{
m_Real.glDepthRangeArrayv(idx, cnt, ranges);
}
delete[] ranges;
return true;
}
bool WrappedOpenGL::Serialise_glScissorArrayv(GLuint index, GLsizei count, const GLint *v)
{
SERIALISE_ELEMENT(uint32_t, idx, index);
SERIALISE_ELEMENT(uint32_t, cnt, count);
SERIALISE_ELEMENT_ARR(GLint, scissors, v, cnt * 4);
if(m_State <= EXECUTING)
{
m_Real.glScissorArrayv(idx, cnt, scissors);
}
delete[] scissors;
return true;
}
bool WrappedOpenGL::Serialise_glViewportArrayv(GLuint index, GLuint count, const GLfloat *v)
{
SERIALISE_ELEMENT(uint32_t, idx, index);
SERIALISE_ELEMENT(uint32_t, cnt, count);
SERIALISE_ELEMENT_ARR(GLfloat, views, v, cnt * 4);
if(m_State <= EXECUTING)
{
m_Real.glViewportArrayv(idx, cnt, views);
}
delete[] views;
return true;
}
bool WrappedOpenGL::Serialise_glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params)
{
SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));
SERIALISE_ELEMENT(GLenum, PName, pname);
const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U);
SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams);
if(m_State < WRITING)
{
GLResource res = GetResourceManager()->GetLiveResource(id);
m_Real.glSamplerParameterIiv(res.name, PName, Params);
}
delete[] Params;
return true;
}
bool WrappedOpenGL::Serialise_glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params)
{
SERIALISE_ELEMENT(GLenum, Target, target);
SERIALISE_ELEMENT(GLenum, PName, pname);
SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture)));
const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U);
SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams);
if(m_State < WRITING)
{
m_Real.glTextureParameterivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params);
}
delete[] Params;
return true;
}
bool WrappedVulkan::Serialise_vkCmdSetScissor(Serialiser *localSerialiser,
VkCommandBuffer cmdBuffer, uint32_t firstScissor,
uint32_t scissorCount, const VkRect2D *pScissors)
{
SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer));
SERIALISE_ELEMENT(uint32_t, first, firstScissor);
SERIALISE_ELEMENT(uint32_t, count, scissorCount);
SERIALISE_ELEMENT_ARR(VkRect2D, scissors, pScissors, count);
Serialise_DebugMessages(localSerialiser, false);
if(m_State < WRITING)
m_LastCmdBufferID = cmdid;
if(m_State == EXECUTING)
{
if(ShouldRerecordCmd(cmdid) && InRerecordRange(cmdid))
{
cmdBuffer = RerecordCmdBuf(cmdid);
ObjDisp(cmdBuffer)->CmdSetScissor(Unwrap(cmdBuffer), first, count, scissors);
if(m_RenderState.scissors.size() < first + count)
m_RenderState.scissors.resize(first + count);
for(uint32_t i = 0; i < count; i++)
m_RenderState.scissors[first + i] = scissors[i];
}
}
else if(m_State == READING)
{
cmdBuffer = GetResourceManager()->GetLiveHandle<VkCommandBuffer>(cmdid);
ObjDisp(cmdBuffer)->CmdSetScissor(Unwrap(cmdBuffer), first, count, scissors);
}
SAFE_DELETE_ARRAY(scissors);
return true;
}
bool WrappedOpenGL::Serialise_glFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs)
{
SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(FramebufferRes(GetCtx(), framebuffer)));
SERIALISE_ELEMENT(uint32_t, num, n);
SERIALISE_ELEMENT_ARR(GLenum, buffers, bufs, num);
if(m_State < WRITING)
{
for(uint32_t i=0; i < num; i++)
{
// since we are faking the default framebuffer with our own
// to see the results, replace back/front/left/right with color attachment 0
if(buffers[i] == eGL_BACK_LEFT || buffers[i] == eGL_BACK_RIGHT || buffers[i] == eGL_BACK ||
buffers[i] == eGL_FRONT_LEFT || buffers[i] == eGL_FRONT_RIGHT || buffers[i] == eGL_FRONT)
buffers[i] = eGL_COLOR_ATTACHMENT0;
}
m_Real.glFramebufferDrawBuffersEXT(GetResourceManager()->GetLiveResource(Id).name, num, buffers);
}
delete[] buffers;
return true;
}
bool WrappedVulkan::Serialise_vkCmdWaitEvents(
Serialiser* localSerialiser,
VkCommandBuffer cmdBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers)
{
SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer));
SERIALISE_ELEMENT(VkPipelineStageFlagBits, srcStages, (VkPipelineStageFlagBits)srcStageMask);
SERIALISE_ELEMENT(VkPipelineStageFlagBits, destStages, (VkPipelineStageFlagBits)dstStageMask);
// we don't serialise the original events as we are going to replace this
// with our own
SERIALISE_ELEMENT(uint32_t, memCount, memoryBarrierCount);
SERIALISE_ELEMENT(uint32_t, bufCount, bufferMemoryBarrierCount);
SERIALISE_ELEMENT(uint32_t, imgCount, imageMemoryBarrierCount);
// we keep the original memory barriers
SERIALISE_ELEMENT_ARR(VkMemoryBarrier, memBarriers, pMemoryBarriers, memCount);
SERIALISE_ELEMENT_ARR(VkBufferMemoryBarrier, bufMemBarriers, pBufferMemoryBarriers, bufCount);
SERIALISE_ELEMENT_ARR(VkImageMemoryBarrier, imgMemBarriers, pImageMemoryBarriers, imgCount);
vector<VkImageMemoryBarrier> imgBarriers;
vector<VkBufferMemoryBarrier> bufBarriers;
// it's possible for buffer or image to be NULL if it refers to a resource that is otherwise
// not in the log (barriers do not mark resources referenced). If the resource in question does
// not exist, then it's safe to skip this barrier.
if(m_State < WRITING)
{
for(uint32_t i=0; i < bufCount; i++)
if(bufMemBarriers[i].buffer != VK_NULL_HANDLE)
bufBarriers.push_back(bufMemBarriers[i]);
for(uint32_t i=0; i < imgCount; i++)
{
if(imgMemBarriers[i].image != VK_NULL_HANDLE)
{
imgBarriers.push_back(imgMemBarriers[i]);
ReplacePresentableImageLayout(imgBarriers.back().oldLayout);
ReplacePresentableImageLayout(imgBarriers.back().newLayout);
}
}
}
SAFE_DELETE_ARRAY(bufMemBarriers);
SAFE_DELETE_ARRAY(imgMemBarriers);
// see top of this file for current event/fence handling
if(m_State == EXECUTING)
{
if(ShouldRerecordCmd(cmdid) && InRerecordRange())
{
cmdBuffer = RerecordCmdBuf(cmdid);
VkEventCreateInfo evInfo = {
VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, NULL, 0,
};
VkEvent ev = VK_NULL_HANDLE;
ObjDisp(cmdBuffer)->CreateEvent(Unwrap(GetDev()), &evInfo, NULL, &ev);
// don't wrap this event
ObjDisp(cmdBuffer)->ResetEvent(Unwrap(GetDev()), ev);
ObjDisp(cmdBuffer)->CmdSetEvent(Unwrap(cmdBuffer), ev, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
ObjDisp(cmdBuffer)->CmdWaitEvents(Unwrap(cmdBuffer), 1, &ev, (VkPipelineStageFlags)srcStages, (VkPipelineStageFlags)destStages,
memCount, memBarriers,
(uint32_t)bufBarriers.size(), &bufBarriers[0],
(uint32_t)imgBarriers.size(), &imgBarriers[0]);
// register to clean this event up once we're done replaying this section of the log
m_CleanupEvents.push_back(ev);
ResourceId cmd = GetResID(RerecordCmdBuf(cmdid));
GetResourceManager()->RecordBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts, (uint32_t)imgBarriers.size(), &imgBarriers[0]);
}
}
else if(m_State == READING)
{
cmdBuffer = GetResourceManager()->GetLiveHandle<VkCommandBuffer>(cmdid);
VkEventCreateInfo evInfo = {
VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, NULL, 0,
};
VkEvent ev = VK_NULL_HANDLE;
ObjDisp(cmdBuffer)->CreateEvent(Unwrap(GetDev()), &evInfo, NULL, &ev);
// don't wrap this event
ObjDisp(cmdBuffer)->ResetEvent(Unwrap(GetDev()), ev);
ObjDisp(cmdBuffer)->CmdSetEvent(Unwrap(cmdBuffer), ev, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
ObjDisp(cmdBuffer)->CmdWaitEvents(Unwrap(cmdBuffer), 1, &ev, (VkPipelineStageFlags)srcStages, (VkPipelineStageFlags)destStages,
memCount, memBarriers,
(uint32_t)bufBarriers.size(), &bufBarriers[0],
(uint32_t)imgBarriers.size(), &imgBarriers[0]);
// register to clean this event up once we're done replaying this section of the log
m_CleanupEvents.push_back(ev);
ResourceId cmd = GetResID(cmdBuffer);
GetResourceManager()->RecordBarriers(m_BakedCmdBufferInfo[cmd].imgbarriers, m_ImageLayouts, (uint32_t)imgBarriers.size(), &imgBarriers[0]);
}
SAFE_DELETE_ARRAY(memBarriers);
return true;
}
