kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring push KRPipeline::m_pushConstantOffset and KRPipeline::m_pushConstantSize in preparation to support push constants for multiple shader stages

Browse Source
This commit is contained in:
Kearwood Gilbert
2022-08-01 23:44:46 -07:00
parent f52ddc007f
commit 74ed52fefd
3 changed files with 56 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
kraken/KRMaterial.cpp
View File

@@ -357,7 +357,7 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_RIM_POWER, rim_power); pShader->setUniform(KRPipeline::KRENGINE_UNIFORM_RIM_POWER, rim_power);
// Bind bones // Bind bones
if(pShader->m_pushConstantOffset[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) { if(pShader->m_pushConstants[0].offset[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) {
float bone_mats[256 * 16]; float bone_mats[256 * 16];
float *bone_mat_component = bone_mats; float *bone_mat_component = bone_mats;
for(int bone_index=0; bone_index < bones.size(); bone_index++) { for(int bone_index=0; bone_index < bones.size(); bone_index++) {
@@ -384,8 +384,8 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
*bone_mat_component++ = t[i]; *bone_mat_component++ = t[i];
} }
} }
if(pShader->m_pushConstantOffset[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) { if(pShader->m_pushConstants[0].offset[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS] != -1) {
glUniformMatrix4fv(pShader->m_pushConstantOffset[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS], (GLsizei)bones.size(), GL_FALSE, bone_mats); glUniformMatrix4fv(pShader->m_pushConstants[0].offset[KRPipeline::KRENGINE_UNIFORM_BONE_TRANSFORMS], (GLsizei)bones.size(), GL_FALSE, bone_mats);
} }
} }

72
kraken/KRPipeline.cpp
View File

@@ -115,8 +115,8 @@ KRPipeline::KRPipeline(KRContext& context, KRSurface& surface, const PipelineInf
, m_pushConstantBuffer(nullptr) , m_pushConstantBuffer(nullptr)
, m_pushConstantBufferSize(0) , m_pushConstantBufferSize(0)
{ {
memset(m_pushConstantSize, 0, KRENGINE_NUM_UNIFORMS); memset(m_pushConstants[0].size, 0, KRENGINE_NUM_UNIFORMS);
memset(m_pushConstantOffset, 0, KRENGINE_NUM_UNIFORMS * sizeof(int)); memset(m_pushConstants[0].offset, 0, KRENGINE_NUM_UNIFORMS * sizeof(int));
m_pipelineLayout = nullptr; m_pipelineLayout = nullptr;
m_graphicsPipeline = nullptr; m_graphicsPipeline = nullptr;
@@ -201,8 +201,8 @@ KRPipeline::KRPipeline(KRContext& context, KRSurface& surface, const PipelineInf
const SpvReflectBlockVariable& member = block.members[iMember]; const SpvReflectBlockVariable& member = block.members[iMember];
if (stricmp(KRENGINE_UNIFORM_NAMES[iUniform], member.name) == 0) if (stricmp(KRENGINE_UNIFORM_NAMES[iUniform], member.name) == 0)
{ {
m_pushConstantOffset[iUniform] = member.offset; m_pushConstants[0].offset[iUniform] = member.offset;
m_pushConstantSize[iUniform] = member.size; m_pushConstants[0].size[iUniform] = member.size;
} }
} }
} }
@@ -475,47 +475,47 @@ KRPipeline::~KRPipeline() {
void KRPipeline::setUniform(int location, float value) void KRPipeline::setUniform(int location, float value)
{ {
if (m_pushConstantSize[location] == sizeof(value)) { if (m_pushConstants[0].size[location] == sizeof(value)) {
float* constant = (float*)(m_pushConstantBuffer + m_pushConstantOffset[location]); float* constant = (float*)(m_pushConstantBuffer + m_pushConstants[0].offset[location]);
*constant = value; *constant = value;
} }
} }
void KRPipeline::setUniform(int location, int value) void KRPipeline::setUniform(int location, int value)
{ {
if (m_pushConstantSize[location] == sizeof(value)) { if (m_pushConstants[0].size[location] == sizeof(value)) {
int* constant = (int*)(m_pushConstantBuffer + m_pushConstantOffset[location]); int* constant = (int*)(m_pushConstantBuffer + m_pushConstants[0].offset[location]);
*constant = value; *constant = value;
} }
} }
void KRPipeline::setUniform(int location, const Vector2 &value) void KRPipeline::setUniform(int location, const Vector2 &value)
{ {
if (m_pushConstantSize[location] == sizeof(value)) { if (m_pushConstants[0].size[location] == sizeof(value)) {
Vector2* constant = (Vector2*)(m_pushConstantBuffer + m_pushConstantOffset[location]); Vector2* constant = (Vector2*)(m_pushConstantBuffer + m_pushConstants[0].offset[location]);
*constant = value; *constant = value;
} }
} }
void KRPipeline::setUniform(int location, const Vector3 &value) void KRPipeline::setUniform(int location, const Vector3 &value)
{ {
if (m_pushConstantSize[location] == sizeof(value)) { if (m_pushConstants[0].size[location] == sizeof(value)) {
Vector3* constant = (Vector3*)(m_pushConstantBuffer + m_pushConstantOffset[location]); Vector3* constant = (Vector3*)(m_pushConstantBuffer + m_pushConstants[0].offset[location]);
*constant = value; *constant = value;
} }
} }
void KRPipeline::setUniform(int location, const Vector4 &value) void KRPipeline::setUniform(int location, const Vector4 &value)
{ {
if (m_pushConstantSize[location] == sizeof(value)) { if (m_pushConstants[0].size[location] == sizeof(value)) {
Vector4* constant = (Vector4*)(m_pushConstantBuffer + m_pushConstantOffset[location]); Vector4* constant = (Vector4*)(m_pushConstantBuffer + m_pushConstants[0].offset[location]);
*constant = value; *constant = value;
} }
} }
void KRPipeline::setUniform(int location, const Matrix4 &value) void KRPipeline::setUniform(int location, const Matrix4 &value)
{ {
if (m_pushConstantSize[location] == sizeof(value)) { if (m_pushConstants[0].size[location] == sizeof(value)) {
Matrix4* constant = (Matrix4*)(m_pushConstantBuffer + m_pushConstantOffset[location]); Matrix4* constant = (Matrix4*)(m_pushConstantBuffer + m_pushConstants[0].offset[location]);
*constant = value; *constant = value;
} }
} }
@@ -536,7 +536,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
KRDirectionalLight* directional_light = (*light_itr); KRDirectionalLight* directional_light = (*light_itr);
if (light_directional_count == 0) { if (light_directional_count == 0) {
int cShadowBuffers = directional_light->getShadowBufferCount(); int cShadowBuffers = directional_light->getShadowBufferCount();
if (m_pushConstantSize[KRENGINE_UNIFORM_SHADOWTEXTURE1] && cShadowBuffers > 0) { if (m_pushConstants[0].size[KRENGINE_UNIFORM_SHADOWTEXTURE1] && cShadowBuffers > 0) {
if (m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 3, directional_light->getShadowTextures()[0])) { if (m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 3, directional_light->getShadowTextures()[0])) {
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
@@ -546,7 +546,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
m_pContext->getTextureManager()->_setWrapModeT(3, GL_CLAMP_TO_EDGE); m_pContext->getTextureManager()->_setWrapModeT(3, GL_CLAMP_TO_EDGE);
} }
if (m_pushConstantSize[KRENGINE_UNIFORM_SHADOWTEXTURE2] && cShadowBuffers > 1 && camera.settings.m_cShadowBuffers > 1) { if (m_pushConstants[0].size[KRENGINE_UNIFORM_SHADOWTEXTURE2] && cShadowBuffers > 1 && camera.settings.m_cShadowBuffers > 1) {
if (m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 4, directional_light->getShadowTextures()[1])) { if (m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 4, directional_light->getShadowTextures()[1])) {
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
@@ -555,7 +555,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
m_pContext->getTextureManager()->_setWrapModeT(4, GL_CLAMP_TO_EDGE); m_pContext->getTextureManager()->_setWrapModeT(4, GL_CLAMP_TO_EDGE);
} }
if (m_pushConstantSize[KRENGINE_UNIFORM_SHADOWTEXTURE3] && cShadowBuffers > 2 && camera.settings.m_cShadowBuffers > 2) { if (m_pushConstants[0].size[KRENGINE_UNIFORM_SHADOWTEXTURE3] && cShadowBuffers > 2 && camera.settings.m_cShadowBuffers > 2) {
if (m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 5, directional_light->getShadowTextures()[2])) { if (m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 5, directional_light->getShadowTextures()[2])) {
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
@@ -571,7 +571,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
setUniform(KRENGINE_UNIFORM_SHADOWMVP1 + iShadow, matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias); setUniform(KRENGINE_UNIFORM_SHADOWMVP1 + iShadow, matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias);
} }
if (m_pushConstantSize[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE]) { if (m_pushConstants[0].size[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE]) {
Matrix4 inverseModelMatrix = matModel; Matrix4 inverseModelMatrix = matModel;
inverseModelMatrix.invert(); inverseModelMatrix.invert();
@@ -590,38 +590,38 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
//light_spot_count = spot_lights.size(); //light_spot_count = spot_lights.size();
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE]) {
Matrix4 inverseModelMatrix = matModel; Matrix4 inverseModelMatrix = matModel;
inverseModelMatrix.invert(); inverseModelMatrix.invert();
if(m_pushConstantSize[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE]) {
// Transform location of camera to object space for calculation of specular halfVec // Transform location of camera to object space for calculation of specular halfVec
Vector3 cameraPosObject = Matrix4::Dot(inverseModelMatrix, viewport.getCameraPosition()); Vector3 cameraPosObject = Matrix4::Dot(inverseModelMatrix, viewport.getCameraPosition());
setUniform(KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE, cameraPosObject); setUniform(KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE, cameraPosObject);
} }
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_MVP] || m_pushConstantSize[KRPipeline::KRENGINE_UNIFORM_INVMVP]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_MVP] || m_pushConstants[0].size[KRPipeline::KRENGINE_UNIFORM_INVMVP]) {
// Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram // Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
Matrix4 mvpMatrix = matModel * viewport.getViewProjectionMatrix(); Matrix4 mvpMatrix = matModel * viewport.getViewProjectionMatrix();
setUniform(KRENGINE_UNIFORM_MVP, mvpMatrix); setUniform(KRENGINE_UNIFORM_MVP, mvpMatrix);
if(m_pushConstantSize[KRPipeline::KRENGINE_UNIFORM_INVMVP]) { if(m_pushConstants[0].size[KRPipeline::KRENGINE_UNIFORM_INVMVP]) {
setUniform(KRPipeline::KRENGINE_UNIFORM_INVMVP, Matrix4::Invert(mvpMatrix)); setUniform(KRPipeline::KRENGINE_UNIFORM_INVMVP, Matrix4::Invert(mvpMatrix));
} }
} }
if(m_pushConstantSize[KRPipeline::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN] || m_pushConstantSize[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE] || m_pushConstantSize[KRPipeline::KRENGINE_UNIFORM_MODEL_VIEW]) { if(m_pushConstants[0].size[KRPipeline::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN] || m_pushConstants[0].size[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE] || m_pushConstants[0].size[KRPipeline::KRENGINE_UNIFORM_MODEL_VIEW]) {
Matrix4 matModelView = matModel * viewport.getViewMatrix(); Matrix4 matModelView = matModel * viewport.getViewMatrix();
setUniform(KRENGINE_UNIFORM_MODEL_VIEW, matModelView); setUniform(KRENGINE_UNIFORM_MODEL_VIEW, matModelView);
if(m_pushConstantSize[KRPipeline::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN]) { if(m_pushConstants[0].size[KRPipeline::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN]) {
Vector3 view_space_model_origin = Matrix4::Dot(matModelView, Vector3::Zero()); // Origin point of model space is the light source position. No perspective, so no w divide required Vector3 view_space_model_origin = Matrix4::Dot(matModelView, Vector3::Zero()); // Origin point of model space is the light source position. No perspective, so no w divide required
setUniform(KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN, view_space_model_origin); setUniform(KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN, view_space_model_origin);
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE]) {
Matrix4 matModelViewInverseTranspose = matModelView; Matrix4 matModelViewInverseTranspose = matModelView;
matModelViewInverseTranspose.transpose(); matModelViewInverseTranspose.transpose();
matModelViewInverseTranspose.invert(); matModelViewInverseTranspose.invert();
@@ -629,18 +629,18 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
} }
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE]) {
Matrix4 matModelInverseTranspose = matModel; Matrix4 matModelInverseTranspose = matModel;
matModelInverseTranspose.transpose(); matModelInverseTranspose.transpose();
matModelInverseTranspose.invert(); matModelInverseTranspose.invert();
setUniform(KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE, matModelInverseTranspose); setUniform(KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE, matModelInverseTranspose);
} }
if(m_pushConstantSize[KRPipeline::KRENGINE_UNIFORM_INVP]) { if(m_pushConstants[0].size[KRPipeline::KRENGINE_UNIFORM_INVP]) {
setUniform(KRENGINE_UNIFORM_INVP, viewport.getInverseProjectionMatrix()); setUniform(KRENGINE_UNIFORM_INVP, viewport.getInverseProjectionMatrix());
} }
if(m_pushConstantSize[KRPipeline::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE]) { if(m_pushConstants[0].size[KRPipeline::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE]) {
Matrix4 matInvMVPNoTranslate = matModel * viewport.getViewMatrix();; Matrix4 matInvMVPNoTranslate = matModel * viewport.getViewMatrix();;
// Remove the translation // Remove the translation
matInvMVPNoTranslate.getPointer()[3] = 0; matInvMVPNoTranslate.getPointer()[3] = 0;
@@ -656,11 +656,11 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
} }
setUniform(KRENGINE_UNIFORM_MODEL_MATRIX, matModel); setUniform(KRENGINE_UNIFORM_MODEL_MATRIX, matModel);
if(m_pushConstantSize[KRENGINE_UNIFORM_PROJECTION_MATRIX]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_PROJECTION_MATRIX]) {
setUniform(KRENGINE_UNIFORM_PROJECTION_MATRIX, viewport.getProjectionMatrix()); setUniform(KRENGINE_UNIFORM_PROJECTION_MATRIX, viewport.getProjectionMatrix());
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_VIEWPORT]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_VIEWPORT]) {
setUniform(KRENGINE_UNIFORM_VIEWPORT, Vector4::Create( setUniform(KRENGINE_UNIFORM_VIEWPORT, Vector4::Create(
(float)0.0, (float)0.0,
(float)0.0, (float)0.0,
@@ -670,7 +670,7 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
); );
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE]) {
setUniform(KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE, camera.getDownsample()); setUniform(KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE, camera.getDownsample());
} }
@@ -680,13 +680,13 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
setUniform(KRENGINE_UNIFORM_FOG_DENSITY, camera.settings.fog_density); setUniform(KRENGINE_UNIFORM_FOG_DENSITY, camera.settings.fog_density);
setUniform(KRENGINE_UNIFORM_FOG_COLOR, camera.settings.fog_color); setUniform(KRENGINE_UNIFORM_FOG_COLOR, camera.settings.fog_color);
if(m_pushConstantSize[KRENGINE_UNIFORM_FOG_SCALE]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_FOG_SCALE]) {
setUniform(KRENGINE_UNIFORM_FOG_SCALE, 1.0f / (camera.settings.fog_far - camera.settings.fog_near)); setUniform(KRENGINE_UNIFORM_FOG_SCALE, 1.0f / (camera.settings.fog_far - camera.settings.fog_near));
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL]) {
setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2) setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2)
} }
if(m_pushConstantSize[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED]) { if(m_pushConstants[0].size[KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED]) {
setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2) setUniform(KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2)
} }

19
kraken/KRPipeline.h
View File

@@ -283,10 +283,25 @@ public:
KRENGINE_UNIFORM_FADE_COLOR, KRENGINE_UNIFORM_FADE_COLOR,
KRENGINE_NUM_UNIFORMS KRENGINE_NUM_UNIFORMS
}; };
enum class ShaderStages : uint8_t
{
vertex = 0,
fragment,
geometry,
compute,
shaderStageCount
};
static const char *KRENGINE_UNIFORM_NAMES[]; static const char *KRENGINE_UNIFORM_NAMES[];
int m_pushConstantOffset[KRENGINE_NUM_UNIFORMS];
__uint8_t m_pushConstantSize[KRENGINE_NUM_UNIFORMS]; struct PushConstantStageInfo
{
int offset[KRENGINE_NUM_UNIFORMS];
__uint8_t size[KRENGINE_NUM_UNIFORMS];
};
PushConstantStageInfo m_pushConstants[static_cast<size_t>(ShaderStages::shaderStageCount)];
uint8_t* m_pushConstantBuffer; uint8_t* m_pushConstantBuffer;
int m_pushConstantBufferSize; int m_pushConstantBufferSize;