InputLightType::enumt readShader(AbcM::IMaterialSchema& matSchema, std::vector<matShader>& shaders)
{
InputLightType::enumt ltype = InputLightType::NUM_INPUT_LIGHT_TYPES;
std::vector<std::string> targetNames;
matSchema.getTargetNames(targetNames);
for(int j=0; j<targetNames.size(); j++){
//ESS_LOG_WARNING("targetName: "<<targetNames[j]);
std::vector<std::string> shaderTypeNames;
matSchema.getShaderTypesForTarget(targetNames[j], shaderTypeNames);
for(int k=0; k<shaderTypeNames.size(); k++){
//ESS_LOG_WARNING("shaderTypeNames: "<<shaderTypeNames[k]);
std::string shaderName;
matSchema.getShader(targetNames[j], shaderTypeNames[k], shaderName);
if(shaderName.find("rect") != std::string::npos || shaderName.find("area") != std::string::npos){
ltype = InputLightType::AREA_LIGHT;
}
else if(shaderName.find("ambient") != std::string::npos){
ltype = InputLightType::AMBIENT_LIGHT;
}
//std::stringstream nameStream;
//nameStream<<targetNames[j]<<"."<<shaderTypeNames[k]<<"."<<shaderName;
shaders.push_back( matShader(targetNames[j], shaderTypeNames[k], shaderName) );
//ESS_LOG_WARNING("shaderName: "<<shaderName);
Abc::ICompoundProperty propk = matSchema.getShaderParameters(targetNames[j], shaderTypeNames[k]);
//ESS_LOG_WARNING("propertyName: "<<propk.getName());
shaders.back().props.push_back(AbcProp(std::string("targetName"), targetNames[j], 1000000000));
shaders.back().props.push_back(AbcProp(std::string("shaderType"), shaderTypeNames[j], 1000000000));
readInputProperties(propk, shaders.back().props);
}
}
return ltype;
}
void Lux::Graphics::RenderingSystem::RenderPass()
{
if (!m_LightEntry || !m_MainCamera || !m_MainCameraTransform)
return;
// Resize Window if needed
if (m_RenderWindow->IsWindowResized())
{
float aspect = m_RenderWindow->GetWidth() / (float)m_RenderWindow->GetHeight();
m_MainCamera->GetRawPtr()->ChangeAspect(aspect);
}
m_MainCameraTransform->GetRawPtr()->ApplyTransform();
EntityMap::iterator it;
for (it = m_EntityMap.begin(); it != m_EntityMap.end(); ++it)
{
if (!it->second.m_Transform)
continue;
if (!it->second.m_MeshRenderer)
continue;
Core::Mesh* mesh = it->second.m_MeshRenderer->GetRawPtr()->GetMesh().get();
if (!mesh)
continue;
// Make sure we multiply the transforms properly, taking into account parents
mat4x4 finalTransform;
Core::Transform* transformPtr = it->second.m_Transform->GetRawPtr();
bool hasParent = true;
do
{
hasParent = transformPtr->GetParentTransform().IsValid();
transformPtr->ApplyTransform();
finalTransform *= transformPtr->GetMatrix();
transformPtr = transformPtr->GetParentTransform().GetRawPtr();
} while (hasParent);
// Set the default uniform buffer
Core::ShaderVariable worldMatVal(Core::VALUE_MAT4X4, glm::value_ptr(finalTransform), sizeof(mat4));
Core::ShaderVariable viewMatVal(Core::VALUE_MAT4X4, glm::value_ptr(m_MainCameraTransform->GetRawPtr()->GetInverseTranslationMatrix()), sizeof(mat4));
Core::ShaderVariable projMatVal(Core::VALUE_MAT4X4, glm::value_ptr(m_MainCamera->GetRawPtr()->GetProjectionMatrix()), sizeof(mat4));
m_ObjUniformBuffer.SetVariable(0, viewMatVal);
m_ObjUniformBuffer.SetVariable(1, projMatVal);
m_ObjUniformBuffer.SetVariable(2, worldMatVal);
// Light Buffer
LightShaderResource lightShaderRes;
lightShaderRes.m_Position = m_LightEntry->m_Transform->GetRawPtr()->GetPosition();
lightShaderRes.m_Color = m_LightEntry->m_Light->GetRawPtr()->GetColor();
lightShaderRes.m_Direction = m_LightEntry->m_Light->GetRawPtr()->GetDirection();
lightShaderRes.m_Intensity = m_LightEntry->m_Light->GetRawPtr()->GetIntensity();
//lightShaderRes.m_Type = (int)m_LightEntry->m_Light->GetRawPtr()->GetType();
Core::ShaderVariable lightShaderVar(Core::VALUE_STRUCT, &lightShaderRes, sizeof(LightShaderResource));
Core::ShaderVariable eyePos(Core::VALUE_VEC3, glm::value_ptr(m_MainCameraTransform->GetRawPtr()->GetPosition()), sizeof(vec3));
m_LightUniformBuffer.SetVariable(0, lightShaderVar);
m_LightUniformBuffer.SetVariable(1, eyePos);
Core::Shader* shader = mesh->GetShader().get();
shader->Activate();
// Material Buffer
Core::Material* matRes = mesh->GetMaterialProperties().get();
MaterialShaderResource matShaderRes(*matRes);
Core::ShaderVariable matShader(Core::VALUE_STRUCT, &matShaderRes, sizeof(MaterialShaderResource));
m_MatUniformBuffer.SetVariable(0, matShader);
if (!it->second.m_Init)
{
shader->InitializeUniformBuffer("ObjectBuffer", m_ObjUniformBuffer, VERTEX_PROGRAM);
shader->InitializeUniformBuffer("LightBuffer", m_LightUniformBuffer, FRAGMENT_PROGRAM);
shader->InitializeUniformBuffer("MaterialBuffer", m_MatUniformBuffer, FRAGMENT_PROGRAM);
it->second.m_Init = true;
}
// Bind Samplers and Textures
Core::Texture2D* diffuseTex = mesh->GetTexture(Core::DIFFUSE_MAP_IDX).get();
LuxAssert(diffuseTex);
Core::TextureSampler* texSampler = diffuseTex->GetSampler().get();
LuxAssert(texSampler);
texSampler->Activate(Core::DIFFUSE_MAP_IDX, FRAGMENT_PROGRAM);
diffuseTex->Bind(Core::DIFFUSE_MAP_IDX, "DiffuseTexture", shader, FRAGMENT_PROGRAM);
shader->Update();
mesh->PreRender();
m_RenderWindow->Render(mesh);
mesh->PostRender();
diffuseTex->Unbind();
texSampler->Deactivate();
shader->Deactivate();
}
}
