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

Reduced verbosity of KRPipeline::Uniform

Browse Source
This commit is contained in:
Kearwood Gilbert
2022-08-02 01:31:13 -07:00
parent 06f4056887
commit b714f7b52a
9 changed files with 236 additions and 236 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kraken/KRCamera.cpp
View File

@@ -550,7 +550,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface)
KRPipeline *postShader = m_pContext->getPipelineManager()->getPipeline(surface, info); KRPipeline *postShader = m_pContext->getPipelineManager()->getPipeline(surface, info);
postShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_FADE_COLOR, m_fade_color); postShader->setUniform(KRPipeline::Uniform::fade_color, m_fade_color);
postShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); postShader->bind(commandBuffer, *this, m_viewport, Matrix4(), nullptr, nullptr, nullptr, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 0, compositeDepthTexture); m_pContext->getTextureManager()->selectTexture(GL_TEXTURE_2D, 0, compositeDepthTexture);

6
kraken/KRDirectionalLight.cpp
View File

@@ -152,9 +152,9 @@ void KRDirectionalLight::render(RenderInfo& ri) {
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE, light_direction_view_space); pShader->setUniform(KRPipeline::Uniform::light_direction_view_space, light_direction_view_space);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_COLOR, m_color); pShader->setUniform(KRPipeline::Uniform::light_color, m_color);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_INTENSITY, m_intensity * 0.01f); pShader->setUniform(KRPipeline::Uniform::light_intensity, m_intensity * 0.01f);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), nullptr, &this_light, nullptr, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), nullptr, &this_light, nullptr, ri.renderPass);
// Render a full screen quad // Render a full screen quad

14
kraken/KRLight.cpp
View File

@@ -270,9 +270,9 @@ void KRLight::render(RenderInfo& ri) {
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
pParticleShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_COLOR, m_color * ri.camera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity); pParticleShader->setUniform(KRPipeline::Uniform::light_color, m_color * ri.camera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity);
pParticleShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_PARTICLE_ORIGIN, Matrix4::DotWDiv(Matrix4::Invert(particleModelMatrix), Vector3::Zero())); pParticleShader->setUniform(KRPipeline::Uniform::particle_origin, Matrix4::DotWDiv(Matrix4::Invert(particleModelMatrix), Vector3::Zero()));
pParticleShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_FLARE_SIZE, m_dust_particle_size); pParticleShader->setUniform(KRPipeline::Uniform::flare_size, m_dust_particle_size);
pParticleShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, particleModelMatrix, &this_point_light, &this_directional_light, &this_spot_light, ri.renderPass); pParticleShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, particleModelMatrix, &this_point_light, &this_directional_light, &this_spot_light, ri.renderPass);
m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_RANDOM_PARTICLES, 1.0f); m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_RANDOM_PARTICLES, 1.0f);
@@ -322,8 +322,8 @@ void KRLight::render(RenderInfo& ri) {
float slice_far = -ri.camera->settings.volumetric_environment_max_distance; float slice_far = -ri.camera->settings.volumetric_environment_max_distance;
float slice_spacing = (slice_far - slice_near) / slice_count; float slice_spacing = (slice_far - slice_near) / slice_count;
pFogShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_SLICE_DEPTH_SCALE, Vector2::Create(slice_near, slice_spacing)); pFogShader->setUniform(KRPipeline::Uniform::slice_depth_scale, Vector2::Create(slice_near, slice_spacing));
pFogShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_COLOR, (m_color * ri.camera->settings.volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f)); pFogShader->setUniform(KRPipeline::Uniform::light_color, (m_color * ri.camera->settings.volumetric_environment_intensity * m_intensity * -slice_spacing / 1000.0f));
pFogShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, Matrix4(), &this_point_light, &this_directional_light, &this_spot_light, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE); pFogShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, Matrix4(), &this_point_light, &this_directional_light, &this_spot_light, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE);
m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_VOLUMETRIC_LIGHTING, 1.0f); m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_VOLUMETRIC_LIGHTING, 1.0f);
@@ -411,8 +411,8 @@ void KRLight::render(RenderInfo& ri) {
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_ALPHA, 1.0f); pShader->setUniform(KRPipeline::Uniform::material_alpha, 1.0f);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_FLARE_SIZE, m_flareSize); pShader->setUniform(KRPipeline::Uniform::flare_size, m_flareSize);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);
m_pContext->getTextureManager()->selectTexture(0, m_pFlareTexture, 0.0f, KRTexture::TEXTURE_USAGE_LIGHT_FLARE); m_pContext->getTextureManager()->selectTexture(0, m_pFlareTexture, 0.0f, KRTexture::TEXTURE_USAGE_LIGHT_FLARE);

42
kraken/KRMaterial.cpp
View File

@@ -353,11 +353,11 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
// Rim highlighting parameters // Rim highlighting parameters
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_RIM_COLOR, rim_color); pShader->setUniform(KRPipeline::Uniform::rim_color, rim_color);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_RIM_POWER, rim_power); pShader->setUniform(KRPipeline::Uniform::rim_power, rim_power);
// Bind bones // Bind bones
if(pShader->hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_BONE_TRANSFORMS)) { if(pShader->hasUniform(KRPipeline::Uniform::bone_transforms)) {
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,40 +384,40 @@ void KRMaterial::bind(const KRNode::RenderInfo& ri, ModelFormat modelFormat, __u
*bone_mat_component++ = t[i]; *bone_mat_component++ = t[i];
} }
} }
if(pShader->hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_BONE_TRANSFORMS)) { if(pShader->hasUniform(KRPipeline::Uniform::bone_transforms)) {
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_BONE_TRANSFORMS, (Matrix4*)bone_mats, bones.size()); pShader->setUniform(KRPipeline::Uniform::bone_transforms, (Matrix4*)bone_mats, bones.size());
} }
} }
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_AMBIENT, m_ambientColor + ri.camera->settings.ambient_intensity); pShader->setUniform(KRPipeline::Uniform::material_ambient, m_ambientColor + ri.camera->settings.ambient_intensity);
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) { if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer // We pre-multiply the light color with the material color in the forward renderer
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_DIFFUSE, Vector3::Create(m_diffuseColor.x * ri.camera->settings.light_intensity.x, m_diffuseColor.y * ri.camera->settings.light_intensity.y, m_diffuseColor.z * ri.camera->settings.light_intensity.z)); pShader->setUniform(KRPipeline::Uniform::material_diffuse, Vector3::Create(m_diffuseColor.x * ri.camera->settings.light_intensity.x, m_diffuseColor.y * ri.camera->settings.light_intensity.y, m_diffuseColor.z * ri.camera->settings.light_intensity.z));
} else { } else {
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_DIFFUSE, m_diffuseColor); pShader->setUniform(KRPipeline::Uniform::material_diffuse, m_diffuseColor);
} }
if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) { if(ri.renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer // We pre-multiply the light color with the material color in the forward renderer
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_SPECULAR, Vector3::Create(m_specularColor.x * ri.camera->settings.light_intensity.x, m_specularColor.y * ri.camera->settings.light_intensity.y, m_specularColor.z * ri.camera->settings.light_intensity.z)); pShader->setUniform(KRPipeline::Uniform::material_specular, Vector3::Create(m_specularColor.x * ri.camera->settings.light_intensity.x, m_specularColor.y * ri.camera->settings.light_intensity.y, m_specularColor.z * ri.camera->settings.light_intensity.z));
} else { } else {
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_SPECULAR, m_specularColor); pShader->setUniform(KRPipeline::Uniform::material_specular, m_specularColor);
} }
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_SHININESS, m_ns); pShader->setUniform(KRPipeline::Uniform::material_shininess, m_ns);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_REFLECTION, m_reflectionColor); pShader->setUniform(KRPipeline::Uniform::material_reflection, m_reflectionColor);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE, m_diffuseMapScale); pShader->setUniform(KRPipeline::Uniform::diffusetexture_scale, m_diffuseMapScale);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE, m_specularMapScale); pShader->setUniform(KRPipeline::Uniform::speculartexture_scale, m_specularMapScale);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE, m_reflectionMapScale); pShader->setUniform(KRPipeline::Uniform::reflectiontexture_scale, m_reflectionMapScale);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_NORMALTEXTURE_SCALE, m_normalMapScale); pShader->setUniform(KRPipeline::Uniform::normaltexture_scale, m_normalMapScale);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET, m_diffuseMapOffset); pShader->setUniform(KRPipeline::Uniform::diffusetexture_offset, m_diffuseMapOffset);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET, m_specularMapOffset); pShader->setUniform(KRPipeline::Uniform::speculartexture_offset, m_specularMapOffset);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET, m_reflectionMapOffset); pShader->setUniform(KRPipeline::Uniform::reflectiontexture_offset, m_reflectionMapOffset);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET, m_normalMapOffset); pShader->setUniform(KRPipeline::Uniform::normaltexture_offset, m_normalMapOffset);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_ALPHA, m_tr); pShader->setUniform(KRPipeline::Uniform::material_alpha, m_tr);
if(bDiffuseMap) { if(bDiffuseMap) {
m_pContext->getTextureManager()->selectTexture(0, m_pDiffuseMap, lod_coverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP); m_pContext->getTextureManager()->selectTexture(0, m_pDiffuseMap, lod_coverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP);

2
kraken/KRParticleSystemNewtonian.cpp
View File

@@ -104,7 +104,7 @@ void KRParticleSystemNewtonian::render(RenderInfo& ri) {
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline *pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
pParticleShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_FLARE_SIZE, 1.0f); pParticleShader->setUniform(KRPipeline::Uniform::flare_size, 1.0f);
pParticleShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pParticleShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);
m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_RANDOM_PARTICLES, 1.0f); m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_RANDOM_PARTICLES, 1.0f);

254
kraken/KRPipeline.cpp
View File

@@ -40,74 +40,74 @@
const char *KRPipeline::KRENGINE_UNIFORM_NAMES[] = { const char *KRPipeline::KRENGINE_UNIFORM_NAMES[] = {
"material_ambient", // KRENGINE_UNIFORM_MATERIAL_AMBIENT "material_ambient", // Uniform::material_ambient
"material_diffuse", // KRENGINE_UNIFORM_MATERIAL_DIFFUSE "material_diffuse", // Uniform::material_diffuse
"material_specular", // KRENGINE_UNIFORM_MATERIAL_SPECULAR "material_specular", // Uniform::material_specular
"material_reflection", // KRENGINE_UNIFORM_MATERIAL_REFLECTION "material_reflection", // Uniform::material_reflection
"material_alpha", // KRENGINE_UNIFORM_MATERIAL_ALPHA "material_alpha", // Uniform::material_alpha
"material_shininess", // KRENGINE_UNIFORM_MATERIAL_SHININESS "material_shininess", // Uniform::material_shininess
"light_position", // KRENGINE_UNIFORM_LIGHT_POSITION "light_position", // Uniform::light_position
"light_direction_model_space", // KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE "light_direction_model_space", // Uniform::light_direction_model_space
"light_direction_view_space", // KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE "light_direction_view_space", // Uniform::light_direction_view_space
"light_color", // KRENGINE_UNIFORM_LIGHT_COLOR "light_color", // Uniform::light_color
"light_decay_start", // KRENGINE_UNIFORM_LIGHT_DECAY_START "light_decay_start", // Uniform::light_decay_start
"light_cutoff", // KRENGINE_UNIFORM_LIGHT_CUTOFF "light_cutoff", // Uniform::light_cutoff
"light_intensity", // KRENGINE_UNIFORM_LIGHT_INTENSITY "light_intensity", // Uniform::light_intensity
"flare_size", // KRENGINE_UNIFORM_FLARE_SIZE "flare_size", // Uniform::flare_size
"view_space_model_origin", // KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN "view_space_model_origin", // Uniform::view_space_model_origin
"mvp_matrix", // KRENGINE_UNIFORM_MVP "mvp_matrix", // Uniform::mvp
"inv_projection_matrix", // KRENGINE_UNIFORM_INVP "inv_projection_matrix", // Uniform::invp
"inv_mvp_matrix", // KRENGINE_UNIFORM_INVMVP "inv_mvp_matrix", // Uniform::invmvp
"inv_mvp_matrix_no_translate", // KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE "inv_mvp_matrix_no_translate", // Uniform::invmvp_no_translate
"model_view_inverse_transpose_matrix", // KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE "model_view_inverse_transpose_matrix", // Uniform::model_view_inverse_transpose
"model_inverse_transpose_matrix", // KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE "model_inverse_transpose_matrix", // Uniform::model_inverse_transpose
"model_view_matrix", // KRENGINE_UNIFORM_MODEL_VIEW "model_view_matrix", // Uniform::model_view
"model_matrix", // KRENGINE_UNIFORM_MODEL_MATRIX "model_matrix", // Uniform::model_matrix
"projection_matrix", // KRENGINE_UNIFORM_PROJECTION_MATRIX "projection_matrix", // Uniform::projection_matrix
"camera_position_model_space", // KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE "camera_position_model_space", // Uniform::camerapos_model_space
"viewport", // KRENGINE_UNIFORM_VIEWPORT "viewport", // Uniform::viewport
"viewport_downsample", // KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE "viewport_downsample", // Uniform::viewport_downsample
"diffuseTexture", // KRENGINE_UNIFORM_DIFFUSETEXTURE "diffuseTexture", // Uniform::diffusetexture
"specularTexture", // KRENGINE_UNIFORM_SPECULARTEXTURE "specularTexture", // Uniform::speculartexture
"reflectionCubeTexture", // KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE "reflectionCubeTexture", // Uniform::reflectioncubetexture
"reflectionTexture", // KRENGINE_UNIFORM_REFLECTIONTEXTURE "reflectionTexture", // Uniform::reflectiontexture
"normalTexture", // KRENGINE_UNIFORM_NORMALTEXTURE "normalTexture", // Uniform::normaltexture
"diffuseTexture_Scale", // KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE "diffuseTexture_Scale", // Uniform::diffusetexture_scale
"specularTexture_Scale", // KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE "specularTexture_Scale", // Uniform::speculartexture_scale
"reflectionTexture_Scale", // KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE "reflectionTexture_Scale", // Uniform::reflectiontexture_scale
"normalTexture_Scale", // KRENGINE_UNIFORM_NORMALTEXTURE_SCALE "normalTexture_Scale", // Uniform::normaltexture_scale
"normalTexture_Scale", // KRENGINE_UNIFORM_AMBIENTTEXTURE_SCALE "normalTexture_Scale", // Uniform::ambienttexture_scale
"diffuseTexture_Offset", // KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET "diffuseTexture_Offset", // Uniform::diffusetexture_offset
"specularTexture_Offset", // KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET "specularTexture_Offset", // Uniform::speculartexture_offset
"reflectionTexture_Offset", // KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET "reflectionTexture_Offset", // Uniform::reflectiontexture_offset
"normalTexture_Offset", // KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET "normalTexture_Offset", // Uniform::normaltexture_offset
"ambientTexture_Offset", // KRENGINE_UNIFORM_AMBIENTTEXTURE_OFFSET "ambientTexture_Offset", // Uniform::ambienttexture_offset
"shadow_mvp1", // KRENGINE_UNIFORM_SHADOWMVP1 "shadow_mvp1", // Uniform::shadow_mvp1
"shadow_mvp2", // KRENGINE_UNIFORM_SHADOWMVP2 "shadow_mvp2", // Uniform::shadow_mvp2
"shadow_mvp3", // KRENGINE_UNIFORM_SHADOWMVP3 "shadow_mvp3", // Uniform::shadow_mvp3
"shadowTexture1", // KRENGINE_UNIFORM_SHADOWTEXTURE1 "shadowTexture1", // Uniform::shadowtexture1
"shadowTexture2", // KRENGINE_UNIFORM_SHADOWTEXTURE2 "shadowTexture2", // Uniform::shadowtexture2
"shadowTexture3", // KRENGINE_UNIFORM_SHADOWTEXTURE3 "shadowTexture3", // Uniform::shadowtexture3
"lightmapTexture", // KRENGINE_UNIFORM_LIGHTMAPTEXTURE "lightmapTexture", // Uniform::lightmaptexture
"gbuffer_frame", // KRENGINE_UNIFORM_GBUFFER_FRAME "gbuffer_frame", // Uniform::gbuffer_frame
"gbuffer_depth", // KRENGINE_UNIFORM_GBUFFER_DEPTH "gbuffer_depth", // Uniform::gbuffer_depth
"depthFrame", // KRENGINE_UNIFORM_DEPTH_FRAME "depthFrame", // Uniform::depth_frame
"volumetricEnvironmentFrame", // KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME "volumetricEnvironmentFrame", // Uniform::volumetric_environment_frame
"renderFrame", // KRENGINE_UNIFORM_RENDER_FRAME "renderFrame", // Uniform::render_frame
"time_absolute", // KRENGINE_UNIFORM_ABSOLUTE_TIME "time_absolute", // Uniform::absolute_time
"fog_near", // KRENGINE_UNIFORM_FOG_NEAR "fog_near", // Uniform::fog_near
"fog_far", // KRENGINE_UNIFORM_FOG_FAR "fog_far", // Uniform::fog_far
"fog_density", // KRENGINE_UNIFORM_FOG_DENSITY "fog_density", // Uniform::fog_density
"fog_color", // KRENGINE_UNIFORM_FOG_COLOR "fog_color", // Uniform::fog_color
"fog_scale", // KRENGINE_UNIFORM_FOG_SCALE "fog_scale", // Uniform::fog_scale
"fog_density_premultiplied_exponential", // KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL "fog_density_premultiplied_exponential", // Uniform::density_premultiplied_exponential
"fog_density_premultiplied_squared", // KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED "fog_density_premultiplied_squared", // Uniform::density_premultiplied_squared
"slice_depth_scale", // KRENGINE_UNIFORM_SLICE_DEPTH_SCALE "slice_depth_scale", // Uniform::slice_depth_scale
"particle_origin", // KRENGINE_UNIFORM_PARTICLE_ORIGIN "particle_origin", // Uniform::particle_origin
"bone_transforms", // KRENGINE_UNIFORM_BONE_TRANSFORMS "bone_transforms", // Uniform::bone_transforms
"rim_color", // KRENGINE_UNIFORM_RIM_COLOR "rim_color", // Uniform::rim_color
"rim_power", // KRENGINE_UNIFORM_RIM_POWER "rim_power", // Uniform::rim_power
"fade_color", // KRENGINE_UNIFORM_FADE_COLOR "fade_color", // Uniform::fade_color
}; };
KRPipeline::KRPipeline(KRContext& context, KRSurface& surface, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat) KRPipeline::KRPipeline(KRContext& context, KRSurface& surface, const PipelineInfo& info, const char* szKey, const std::vector<KRShader*>& shaders, uint32_t vertexAttributes, ModelFormat modelFormat)
@@ -198,7 +198,7 @@ KRPipeline::KRPipeline(KRContext& context, KRSurface& surface, const PipelineInf
m_pushConstantBufferSize = block.size; m_pushConstantBufferSize = block.size;
// Get push constant offsets // Get push constant offsets
for (int iUniform = 0; iUniform < static_cast<int>(Uniform::KRENGINE_NUM_UNIFORMS); iUniform++) { for (int iUniform = 0; iUniform < kUniformCount; iUniform++) {
for (int iMember = 0; iMember < block.member_count; iMember++) { for (int iMember = 0; iMember < block.member_count; iMember++) {
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)
@@ -535,12 +535,12 @@ void KRPipeline::setUniform(Uniform location, const Matrix4 &value)
void KRPipeline::setUniform(Uniform location, const Matrix4* value, const size_t count) void KRPipeline::setUniform(Uniform location, const Matrix4* value, const size_t count)
{ {
// TODO - Vulkan refactoring // TODO - Vulkan refactoring
// GLDEBUG(glUniformMatrix4fv(pShader->m_pushConstants[0].offset[KRPipeline::Uniform::KRENGINE_UNIFORM_BONE_TRANSFORMS], (GLsizei)bones.size(), GL_FALSE, bone_mats)); // GLDEBUG(glUniformMatrix4fv(pShader->m_pushConstants[0].offset[KRPipeline::Uniform::bone_transforms], (GLsizei)bones.size(), GL_FALSE, bone_mats));
} }
bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> *point_lights, const std::vector<KRDirectionalLight *> *directional_lights, const std::vector<KRSpotLight *> *spot_lights, const KRNode::RenderPass &renderPass) bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> *point_lights, const std::vector<KRDirectionalLight *> *directional_lights, const std::vector<KRSpotLight *> *spot_lights, const KRNode::RenderPass &renderPass)
{ {
setUniform(Uniform::KRENGINE_UNIFORM_ABSOLUTE_TIME, getContext().getAbsoluteTime()); setUniform(Uniform::absolute_time, getContext().getAbsoluteTime());
int light_directional_count = 0; int light_directional_count = 0;
//int light_point_count = 0; //int light_point_count = 0;
@@ -554,7 +554,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 (hasUniform(Uniform::KRENGINE_UNIFORM_SHADOWTEXTURE1) && cShadowBuffers > 0) { if (hasUniform(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));
@@ -564,7 +564,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 (hasUniform(Uniform::KRENGINE_UNIFORM_SHADOWTEXTURE2) && cShadowBuffers > 1 && camera.settings.m_cShadowBuffers > 1) { if (hasUniform(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));
@@ -573,7 +573,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 (hasUniform(Uniform::KRENGINE_UNIFORM_SHADOWTEXTURE3) && cShadowBuffers > 2 && camera.settings.m_cShadowBuffers > 2) { if (hasUniform(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));
@@ -586,17 +586,17 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
matBias.translate(1.0, 1.0, 1.0); matBias.translate(1.0, 1.0, 1.0);
matBias.scale(0.5); matBias.scale(0.5);
for (int iShadow = 0; iShadow < cShadowBuffers; iShadow++) { for (int iShadow = 0; iShadow < cShadowBuffers; iShadow++) {
setUniform(static_cast<Uniform>(static_cast<int>(Uniform::KRENGINE_UNIFORM_SHADOWMVP1) + iShadow), matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias); setUniform(static_cast<Uniform>(static_cast<int>(Uniform::shadow_mvp1) + iShadow), matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias);
} }
if (hasUniform(Uniform::KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE)) { if (hasUniform(Uniform::light_direction_model_space)) {
Matrix4 inverseModelMatrix = matModel; Matrix4 inverseModelMatrix = matModel;
inverseModelMatrix.invert(); inverseModelMatrix.invert();
// Bind the light direction vector // Bind the light direction vector
Vector3 lightDirObject = Matrix4::Dot(inverseModelMatrix, directional_light->getWorldLightDirection()); Vector3 lightDirObject = Matrix4::Dot(inverseModelMatrix, directional_light->getWorldLightDirection());
lightDirObject.normalize(); lightDirObject.normalize();
setUniform(Uniform::KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE, lightDirObject); setUniform(Uniform::light_direction_model_space, lightDirObject);
} }
} }
@@ -608,57 +608,57 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
//light_spot_count = spot_lights.size(); //light_spot_count = spot_lights.size();
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE)) { if(hasUniform(Uniform::camerapos_model_space)) {
Matrix4 inverseModelMatrix = matModel; Matrix4 inverseModelMatrix = matModel;
inverseModelMatrix.invert(); inverseModelMatrix.invert();
if(hasUniform(Uniform::KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE)) { if(hasUniform(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(Uniform::KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE, cameraPosObject); setUniform(Uniform::camerapos_model_space, cameraPosObject);
} }
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_MVP) || hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_INVMVP)) { if(hasUniform(Uniform::mvp) || hasUniform(KRPipeline::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(Uniform::KRENGINE_UNIFORM_MVP, mvpMatrix); setUniform(Uniform::mvp, mvpMatrix);
if(hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_INVMVP)) { if(hasUniform(KRPipeline::Uniform::invmvp)) {
setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_INVMVP, Matrix4::Invert(mvpMatrix)); setUniform(KRPipeline::Uniform::invmvp, Matrix4::Invert(mvpMatrix));
} }
} }
if(hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN) || hasUniform(Uniform::KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE) || hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MODEL_VIEW)) { if(hasUniform(KRPipeline::Uniform::view_space_model_origin) || hasUniform(Uniform::model_view_inverse_transpose) || hasUniform(KRPipeline::Uniform::model_view)) {
Matrix4 matModelView = matModel * viewport.getViewMatrix(); Matrix4 matModelView = matModel * viewport.getViewMatrix();
setUniform(Uniform::KRENGINE_UNIFORM_MODEL_VIEW, matModelView); setUniform(Uniform::model_view, matModelView);
if(hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN)) { if(hasUniform(KRPipeline::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(Uniform::KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN, view_space_model_origin); setUniform(Uniform::view_space_model_origin, view_space_model_origin);
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE)) { if(hasUniform(Uniform::model_view_inverse_transpose)) {
Matrix4 matModelViewInverseTranspose = matModelView; Matrix4 matModelViewInverseTranspose = matModelView;
matModelViewInverseTranspose.transpose(); matModelViewInverseTranspose.transpose();
matModelViewInverseTranspose.invert(); matModelViewInverseTranspose.invert();
setUniform(Uniform::KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE, matModelViewInverseTranspose); setUniform(Uniform::model_view_inverse_transpose, matModelViewInverseTranspose);
} }
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE)) { if(hasUniform(Uniform::model_inverse_transpose)) {
Matrix4 matModelInverseTranspose = matModel; Matrix4 matModelInverseTranspose = matModel;
matModelInverseTranspose.transpose(); matModelInverseTranspose.transpose();
matModelInverseTranspose.invert(); matModelInverseTranspose.invert();
setUniform(Uniform::KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE, matModelInverseTranspose); setUniform(Uniform::model_inverse_transpose, matModelInverseTranspose);
} }
if(hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_INVP)) { if(hasUniform(KRPipeline::Uniform::invp)) {
setUniform(Uniform::KRENGINE_UNIFORM_INVP, viewport.getInverseProjectionMatrix()); setUniform(Uniform::invp, viewport.getInverseProjectionMatrix());
} }
if(hasUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE)) { if(hasUniform(KRPipeline::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;
@@ -670,16 +670,16 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
matInvMVPNoTranslate.getPointer()[15] = 1.0; matInvMVPNoTranslate.getPointer()[15] = 1.0;
matInvMVPNoTranslate = matInvMVPNoTranslate * viewport.getProjectionMatrix(); matInvMVPNoTranslate = matInvMVPNoTranslate * viewport.getProjectionMatrix();
matInvMVPNoTranslate.invert(); matInvMVPNoTranslate.invert();
setUniform(Uniform::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE, matInvMVPNoTranslate); setUniform(Uniform::invmvp_no_translate, matInvMVPNoTranslate);
} }
setUniform(Uniform::KRENGINE_UNIFORM_MODEL_MATRIX, matModel); setUniform(Uniform::model_matrix, matModel);
if(hasUniform(Uniform::KRENGINE_UNIFORM_PROJECTION_MATRIX)) { if(hasUniform(Uniform::projection_matrix)) {
setUniform(Uniform::KRENGINE_UNIFORM_PROJECTION_MATRIX, viewport.getProjectionMatrix()); setUniform(Uniform::projection_matrix, viewport.getProjectionMatrix());
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_VIEWPORT)) { if(hasUniform(Uniform::viewport)) {
setUniform(Uniform::KRENGINE_UNIFORM_VIEWPORT, Vector4::Create( setUniform(Uniform::viewport, Vector4::Create(
(float)0.0, (float)0.0,
(float)0.0, (float)0.0,
(float)viewport.getSize().x, (float)viewport.getSize().x,
@@ -688,47 +688,47 @@ bool KRPipeline::bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KR
); );
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE)) { if(hasUniform(Uniform::viewport_downsample)) {
setUniform(Uniform::KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE, camera.getDownsample()); setUniform(Uniform::viewport_downsample, camera.getDownsample());
} }
// Fog parameters // Fog parameters
setUniform(Uniform::KRENGINE_UNIFORM_FOG_NEAR, camera.settings.fog_near); setUniform(Uniform::fog_near, camera.settings.fog_near);
setUniform(Uniform::KRENGINE_UNIFORM_FOG_FAR, camera.settings.fog_far); setUniform(Uniform::fog_far, camera.settings.fog_far);
setUniform(Uniform::KRENGINE_UNIFORM_FOG_DENSITY, camera.settings.fog_density); setUniform(Uniform::fog_density, camera.settings.fog_density);
setUniform(Uniform::KRENGINE_UNIFORM_FOG_COLOR, camera.settings.fog_color); setUniform(Uniform::fog_color, camera.settings.fog_color);
if(hasUniform(Uniform::KRENGINE_UNIFORM_FOG_SCALE)) { if(hasUniform(Uniform::fog_scale)) {
setUniform(Uniform::KRENGINE_UNIFORM_FOG_SCALE, 1.0f / (camera.settings.fog_far - camera.settings.fog_near)); setUniform(Uniform::fog_scale, 1.0f / (camera.settings.fog_far - camera.settings.fog_near));
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL)) { if(hasUniform(Uniform::density_premultiplied_exponential)) {
setUniform(Uniform::KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2) setUniform(Uniform::density_premultiplied_exponential, -camera.settings.fog_density * 1.442695f); // -fog_density / log(2)
} }
if(hasUniform(Uniform::KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED)) { if(hasUniform(Uniform::density_premultiplied_squared)) {
setUniform(Uniform::KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2) setUniform(Uniform::density_premultiplied_squared, (float)(-camera.settings.fog_density * camera.settings.fog_density * 1.442695)); // -fog_density * fog_density / log(2)
} }
// Sets the diffuseTexture variable to the first texture unit // Sets the diffuseTexture variable to the first texture unit
setUniform(Uniform::KRENGINE_UNIFORM_DIFFUSETEXTURE, 0); setUniform(Uniform::diffusetexture, 0);
// Sets the specularTexture variable to the second texture unit // Sets the specularTexture variable to the second texture unit
setUniform(Uniform::KRENGINE_UNIFORM_SPECULARTEXTURE, 1); setUniform(Uniform::speculartexture, 1);
// Sets the normalTexture variable to the third texture unit // Sets the normalTexture variable to the third texture unit
setUniform(Uniform::KRENGINE_UNIFORM_NORMALTEXTURE, 2); setUniform(Uniform::normaltexture, 2);
// Sets the shadowTexture variable to the fourth texture unit // Sets the shadowTexture variable to the fourth texture unit
setUniform(Uniform::KRENGINE_UNIFORM_SHADOWTEXTURE1, 3); setUniform(Uniform::shadowtexture1, 3);
setUniform(Uniform::KRENGINE_UNIFORM_SHADOWTEXTURE2, 4); setUniform(Uniform::shadowtexture2, 4);
setUniform(Uniform::KRENGINE_UNIFORM_SHADOWTEXTURE3, 5); setUniform(Uniform::shadowtexture3, 5);
setUniform(Uniform::KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE, 4); setUniform(Uniform::reflectioncubetexture, 4);
setUniform(Uniform::KRENGINE_UNIFORM_LIGHTMAPTEXTURE, 5); setUniform(Uniform::lightmaptexture, 5);
setUniform(Uniform::KRENGINE_UNIFORM_GBUFFER_FRAME, 6); setUniform(Uniform::gbuffer_frame, 6);
setUniform(Uniform::KRENGINE_UNIFORM_GBUFFER_DEPTH, 7); // Texture unit 7 is used for reading the depth buffer in gBuffer pass #2 and in post-processing pass setUniform(Uniform::gbuffer_depth, 7); // Texture unit 7 is used for reading the depth buffer in gBuffer pass #2 and in post-processing pass
setUniform(Uniform::KRENGINE_UNIFORM_REFLECTIONTEXTURE, 7); // Texture unit 7 is used for the reflection map textures in gBuffer pass #3 and when using forward rendering setUniform(Uniform::reflectiontexture, 7); // Texture unit 7 is used for the reflection map textures in gBuffer pass #3 and when using forward rendering
setUniform(Uniform::KRENGINE_UNIFORM_DEPTH_FRAME, 0); setUniform(Uniform::depth_frame, 0);
setUniform(Uniform::KRENGINE_UNIFORM_RENDER_FRAME, 1); setUniform(Uniform::render_frame, 1);
setUniform(Uniform::KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME, 2); setUniform(Uniform::volumetric_environment_frame, 2);
if(m_pushConstantBuffer) { if(m_pushConstantBuffer) {
vkCmdPushConstants(commandBuffer, m_pushConstantsLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, m_pushConstantBufferSize, m_pushConstantBuffer); vkCmdPushConstants(commandBuffer, m_pushConstantsLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, m_pushConstantBufferSize, m_pushConstantBuffer);

140
kraken/KRPipeline.h
View File

@@ -213,78 +213,78 @@ public:
bool bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> *point_lights, const std::vector<KRDirectionalLight *> *directional_lights, const std::vector<KRSpotLight *>*spot_lights, const KRNode::RenderPass &renderPass); bool bind(VkCommandBuffer& commandBuffer, KRCamera &camera, const KRViewport &viewport, const Matrix4 &matModel, const std::vector<KRPointLight *> *point_lights, const std::vector<KRDirectionalLight *> *directional_lights, const std::vector<KRSpotLight *>*spot_lights, const KRNode::RenderPass &renderPass);
enum class Uniform : uint8_t { enum class Uniform : uint8_t {
KRENGINE_UNIFORM_MATERIAL_AMBIENT = 0, material_ambient = 0,
KRENGINE_UNIFORM_MATERIAL_DIFFUSE, material_diffuse,
KRENGINE_UNIFORM_MATERIAL_SPECULAR, material_specular,
KRENGINE_UNIFORM_MATERIAL_REFLECTION, material_reflection,
KRENGINE_UNIFORM_MATERIAL_ALPHA, material_alpha,
KRENGINE_UNIFORM_MATERIAL_SHININESS, material_shininess,
KRENGINE_UNIFORM_LIGHT_POSITION, light_position,
KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE, light_direction_model_space,
KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE, light_direction_view_space,
KRENGINE_UNIFORM_LIGHT_COLOR, light_color,
KRENGINE_UNIFORM_LIGHT_DECAY_START, light_decay_start,
KRENGINE_UNIFORM_LIGHT_CUTOFF, light_cutoff,
KRENGINE_UNIFORM_LIGHT_INTENSITY, light_intensity,
KRENGINE_UNIFORM_FLARE_SIZE, flare_size,
KRENGINE_UNIFORM_VIEW_SPACE_MODEL_ORIGIN, view_space_model_origin,
KRENGINE_UNIFORM_MVP, mvp,
KRENGINE_UNIFORM_INVP, invp,
KRENGINE_UNIFORM_INVMVP, invmvp,
KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE, invmvp_no_translate,
KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE, model_view_inverse_transpose,
KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE, model_inverse_transpose,
KRENGINE_UNIFORM_MODEL_VIEW, model_view,
KRENGINE_UNIFORM_MODEL_MATRIX, model_matrix,
KRENGINE_UNIFORM_PROJECTION_MATRIX, projection_matrix,
KRENGINE_UNIFORM_CAMERAPOS_MODEL_SPACE, camerapos_model_space,
KRENGINE_UNIFORM_VIEWPORT, viewport,
KRENGINE_UNIFORM_VIEWPORT_DOWNSAMPLE, viewport_downsample,
KRENGINE_UNIFORM_DIFFUSETEXTURE, diffusetexture,
KRENGINE_UNIFORM_SPECULARTEXTURE, speculartexture,
KRENGINE_UNIFORM_REFLECTIONCUBETEXTURE, reflectioncubetexture,
KRENGINE_UNIFORM_REFLECTIONTEXTURE, reflectiontexture,
KRENGINE_UNIFORM_NORMALTEXTURE, normaltexture,
KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE, diffusetexture_scale,
KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE, speculartexture_scale,
KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE, reflectiontexture_scale,
KRENGINE_UNIFORM_NORMALTEXTURE_SCALE, normaltexture_scale,
KRENGINE_UNIFORM_AMBIENTTEXTURE_SCALE, ambienttexture_scale,
KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET, diffusetexture_offset,
KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET, speculartexture_offset,
KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET, reflectiontexture_offset,
KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET, normaltexture_offset,
KRENGINE_UNIFORM_AMBIENTTEXTURE_OFFSET, ambienttexture_offset,
KRENGINE_UNIFORM_SHADOWMVP1, shadow_mvp1,
KRENGINE_UNIFORM_SHADOWMVP2, shadow_mvp2,
KRENGINE_UNIFORM_SHADOWMVP3, shadow_mvp3,
KRENGINE_UNIFORM_SHADOWTEXTURE1, shadowtexture1,
KRENGINE_UNIFORM_SHADOWTEXTURE2, shadowtexture2,
KRENGINE_UNIFORM_SHADOWTEXTURE3, shadowtexture3,
KRENGINE_UNIFORM_LIGHTMAPTEXTURE, lightmaptexture,
KRENGINE_UNIFORM_GBUFFER_FRAME, gbuffer_frame,
KRENGINE_UNIFORM_GBUFFER_DEPTH, gbuffer_depth,
KRENGINE_UNIFORM_DEPTH_FRAME, depth_frame,
KRENGINE_UNIFORM_VOLUMETRIC_ENVIRONMENT_FRAME, volumetric_environment_frame,
KRENGINE_UNIFORM_RENDER_FRAME, render_frame,
KRENGINE_UNIFORM_ABSOLUTE_TIME, absolute_time,
KRENGINE_UNIFORM_FOG_NEAR, fog_near,
KRENGINE_UNIFORM_FOG_FAR, fog_far,
KRENGINE_UNIFORM_FOG_DENSITY, fog_density,
KRENGINE_UNIFORM_FOG_COLOR, fog_color,
KRENGINE_UNIFORM_FOG_SCALE, fog_scale,
KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_EXPONENTIAL, density_premultiplied_exponential,
KRENGINE_UNIFORM_DENSITY_PREMULTIPLIED_SQUARED, density_premultiplied_squared,
KRENGINE_UNIFORM_SLICE_DEPTH_SCALE, slice_depth_scale,
KRENGINE_UNIFORM_PARTICLE_ORIGIN, particle_origin,
KRENGINE_UNIFORM_BONE_TRANSFORMS, bone_transforms,
KRENGINE_UNIFORM_RIM_COLOR, rim_color,
KRENGINE_UNIFORM_RIM_POWER, rim_power,
KRENGINE_UNIFORM_FADE_COLOR, fade_color,
KRENGINE_NUM_UNIFORMS NUM_UNIFORMS
}; };
static const size_t kUniformCount = static_cast<size_t>(Uniform::KRENGINE_NUM_UNIFORMS); static const size_t kUniformCount = static_cast<size_t>(Uniform::NUM_UNIFORMS);
enum class ShaderStages : uint8_t enum class ShaderStages : uint8_t
{ {

10
kraken/KRPointLight.cpp
View File

@@ -112,11 +112,11 @@ void KRPointLight::render(RenderInfo& ri)
info.modelFormat = bInsideLight ? ModelFormat::KRENGINE_MODEL_FORMAT_STRIP : ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES; info.modelFormat = bInsideLight ? ModelFormat::KRENGINE_MODEL_FORMAT_STRIP : ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_COLOR, m_color); pShader->setUniform(KRPipeline::Uniform::light_color, m_color);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_INTENSITY, m_intensity * 0.01f); pShader->setUniform(KRPipeline::Uniform::light_intensity, m_intensity * 0.01f);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_DECAY_START, getDecayStart()); pShader->setUniform(KRPipeline::Uniform::light_decay_start, getDecayStart());
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_CUTOFF, KRLIGHT_MIN_INFLUENCE); pShader->setUniform(KRPipeline::Uniform::light_cutoff, KRLIGHT_MIN_INFLUENCE);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_LIGHT_POSITION, light_position); pShader->setUniform(KRPipeline::Uniform::light_position, light_position);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &this_light, nullptr, nullptr, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, sphereModelMatrix, &this_light, nullptr, nullptr, ri.renderPass);
if(bInsideLight) { if(bInsideLight) {

2
kraken/KRSprite.cpp
View File

@@ -158,7 +158,7 @@ void KRSprite::render(RenderInfo& ri) {
info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP; info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_STRIP;
KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info); KRPipeline *pShader = getContext().getPipelineManager()->getPipeline(*ri.surface, info);
pShader->setUniform(KRPipeline::Uniform::KRENGINE_UNIFORM_MATERIAL_ALPHA, m_spriteAlpha); pShader->setUniform(KRPipeline::Uniform::material_alpha, m_spriteAlpha);
pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass); pShader->bind(ri.commandBuffer, *ri.camera, ri.viewport, getModelMatrix(), &ri.point_lights, &ri.directional_lights, &ri.spot_lights, ri.renderPass);
m_pContext->getTextureManager()->selectTexture(0, m_pSpriteTexture, 0.0f, KRTexture::TEXTURE_USAGE_SPRITE); m_pContext->getTextureManager()->selectTexture(0, m_pSpriteTexture, 0.0f, KRTexture::TEXTURE_USAGE_SPRITE);