void MeshRenderProcessorGL::process() {
if (imageInport_.isConnected()){
utilgl::activateTargetAndCopySource(outport_, imageInport_);
}
else{
utilgl::activateAndClearTarget(outport_, COLOR_DEPTH);
}
shader_.activate();
utilgl::setShaderUniforms(shader_, camera_, "camera_");
utilgl::setShaderUniforms(shader_, lightingProperty_, "light_");
utilgl::setShaderUniforms(shader_, overrideColor_);
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true);
utilgl::CullFaceState culling(cullFace_.get());
utilgl::PolygonModeState polygon(polygonMode_.get(), renderLineWidth_, renderPointSize_);
for (auto& drawer : drawers_) {
utilgl::setShaderUniforms(shader_, *(drawer.second->getGeometry()), "geometry_");
drawer.second->draw();
}
shader_.deactivate();
utilgl::deactivateCurrentTarget();
}
void MeshPicking::process() {
utilgl::activateAndClearTarget(outport_, ImageType::ColorDepthPicking);
MeshDrawerGL drawer(meshInport_.getData().get());
shader_.activate();
shader_.setUniform("pickingColor_", picking_.getPickingObject()->getPickingColor());
const auto& ct = meshInport_.getData()->getCoordinateTransformer(camera_.get());
mat4 dataToClip =
ct.getWorldToClipMatrix() * glm::translate(position_.get()) * ct.getDataToWorldMatrix();
shader_.setUniform("dataToClip", dataToClip);
{
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true);
utilgl::CullFaceState culling(cullFace_.get());
utilgl::DepthFuncState depthfunc(GL_ALWAYS);
drawer.draw();
}
shader_.deactivate();
utilgl::deactivateCurrentTarget();
compositePortsToOutport(outport_, ImageType::ColorDepthPicking, imageInport_);
}
void PassGBuffer_Fluid::addParticlesSolid( PSET_RID psid, const PSetInstance &inst, uint32 n )
{
if(!culling(psid, inst)) { return; }
const ParticleSet *rc = atmGetParticleSet(psid);
uint32 num_particles = rc->getNumParticles();
PSetUpdateInfo tmp;
tmp.psid = psid;
tmp.instanceid = m_rigid_so.instance_data.size();
tmp.num = n!=0 ? std::min(n, num_particles) : num_particles;
m_rigid_so.update_info.push_back(tmp);
m_rigid_so.instance_data.push_back(inst);
}
void MeshRenderProcessorGLSR::process() {
/* if (imageInport_.isConnected()) {
utilgl::activateTargetAndCopySource(outport_, imageInport_);
} else {
utilgl::activateAndClearTarget(outport_, ImageType::ColorDepth);
} */
utilgl::activateAndClearTarget(outport_, ImageType::ColorDepth);
if (meshName_.isConnected())
{
auto inDescr = *meshName_.getData();
sceneDesc_->setInputName(inDescr.getInputName());
}
//LogInfo(inport_.getContentInfo());
//LogInfo(inport_.getClassIdentifier());
shader_.activate();
utilgl::setShaderUniforms(shader_, camera_, "camera_");
//std::cout << "Camera Position = " << camera_.position.x
LogInfo(camera_.getLookFrom());
utilgl::setShaderUniforms(shader_, lightingProperty_, "light_");
LogInfo(lightingProperty_.silhouetteThreshold_);
LogInfo(lightingProperty_.depthThreshold_);
LogInfo(lightingProperty_.specularExponent_);
utilgl::setShaderUniforms(shader_, lightingProperty_.silhouetteThreshold_, "threshold_sil");
utilgl::setShaderUniforms(shader_, lightingProperty_.depthThreshold_, "threshold_depth");
utilgl::setShaderUniforms(shader_, overrideColor_);
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, enableDepthTest_.get());
utilgl::CullFaceState culling(cullFace_.get());
utilgl::PolygonModeState polygon(polygonMode_.get(), renderLineWidth_, renderPointSize_);
for (auto& drawer : drawers_) {
utilgl::setShaderUniforms(shader_, *(drawer.second->getGeometry()), "geometry_");
drawer.second->draw();
}
sceneDesc_->setImageDimensions(outport_.getDimensions());
sceneDesc_->setShaderName(lightingProperty_.shadingMode_.getSelectedDisplayName());
sceneDesc_->setLayerDescription(layersDeclaration_);
/*setImageDimensions(*sceneDesc_);
setShaderName(*sceneDesc_);
setLayerDescription(*sceneDesc_);*/
sceneDesc_->printDescription();
sceneDescOutport_.setData(sceneDesc_);
utilgl::deactivateCurrentTarget();
}
void run()
{
renderer.running = true;
while (renderer.running) {
Profiler::start_timer("-> Frame time");
handle_input();
update_camera();
animate_models();
culling();
renderer.render(camera);
Profiler::start_timer("Swap");
SDL_GL_SwapWindow(main_window);
Profiler::stop_timer("Swap");
Profiler::stop_timer("-> Frame time");
}
}
void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph, float motion_time)
{
/* layer data */
bool motion = motion_time != 0.0f;
if (!motion) {
/* prepare for sync */
light_map.pre_sync();
mesh_map.pre_sync();
object_map.pre_sync();
particle_system_map.pre_sync();
motion_times.clear();
}
else {
mesh_motion_synced.clear();
}
/* initialize culling */
BlenderObjectCulling culling(scene, b_scene);
/* object loop */
bool cancel = false;
bool use_portal = false;
BL::ViewLayer b_view_layer = b_depsgraph.view_layer_eval();
BL::Depsgraph::object_instances_iterator b_instance_iter;
for (b_depsgraph.object_instances.begin(b_instance_iter);
b_instance_iter != b_depsgraph.object_instances.end() && !cancel;
++b_instance_iter) {
BL::DepsgraphObjectInstance b_instance = *b_instance_iter;
BL::Object b_ob = b_instance.object();
/* load per-object culling data */
culling.init_object(scene, b_ob);
/* test if object needs to be hidden */
const bool show_self = b_instance.show_self();
const bool show_particles = b_instance.show_particles();
if (show_self || show_particles) {
/* object itself */
sync_object(b_depsgraph,
b_view_layer,
b_instance,
motion_time,
show_self,
show_particles,
culling,
&use_portal);
}
cancel = progress.get_cancel();
}
progress.set_sync_status("");
if (!cancel && !motion) {
sync_background_light(use_portal);
/* handle removed data and modified pointers */
if (light_map.post_sync())
scene->light_manager->tag_update(scene);
if (mesh_map.post_sync())
scene->mesh_manager->tag_update(scene);
if (object_map.post_sync())
scene->object_manager->tag_update(scene);
if (particle_system_map.post_sync())
scene->particle_system_manager->tag_update(scene);
}
if (motion)
mesh_motion_synced.clear();
}
void WIPCamera::culling(WIPLayer* layer)
{
culling(layer,((WIPObjectsLayer*)layer)->_batch);
}
void RenderMeshComponent::AddFromRawData(corgi::EntityRef& entity,
const void* raw_data) {
auto rendermesh_def = static_cast<const RenderMeshDef*>(raw_data);
// You need to call asset_manager before you can add from raw data,
// otherwise it can't load up new meshes!
assert(asset_manager_ != nullptr);
assert(rendermesh_def->source_file() != nullptr);
assert(rendermesh_def->shader() != nullptr);
RenderMeshData* rendermesh_data = AddEntity(entity);
rendermesh_data->mesh_filename = rendermesh_def->source_file()->c_str();
rendermesh_data->shader_filename = rendermesh_def->shader()->c_str();
rendermesh_data->mesh =
asset_manager_->LoadMesh(rendermesh_def->source_file()->c_str());
assert(rendermesh_data->mesh != nullptr);
// Allocate the array to hold shader default pose's transforms.
assert(rendermesh_data->shader_transforms == nullptr);
const uint8_t num_shader_transforms =
rendermesh_data->mesh->num_shader_bones();
rendermesh_data->num_shader_transforms = num_shader_transforms;
if (num_shader_transforms > 0) {
rendermesh_data->shader_transforms =
new mathfu::AffineTransform[num_shader_transforms];
for (uint8_t i = 0; i < num_shader_transforms; ++i) {
rendermesh_data->shader_transforms[i] = mathfu::kAffineIdentity;
}
}
rendermesh_data->shader =
asset_manager_->LoadShader(rendermesh_def->shader()->c_str());
assert(rendermesh_data->shader != nullptr);
rendermesh_data->visible = rendermesh_def->visible();
rendermesh_data->default_pose = rendermesh_def->default_pose();
rendermesh_data->pass_mask = 0;
if (rendermesh_def->render_pass() != nullptr) {
for (size_t i = 0; i < rendermesh_def->render_pass()->size(); i++) {
int render_pass = rendermesh_def->render_pass()->Get(i);
assert(render_pass < RenderPass_Count);
rendermesh_data->pass_mask |= 1 << render_pass;
}
} else {
// Anything unspecified is assumed to be opaque.
rendermesh_data->pass_mask = (1 << RenderPass_Opaque);
}
if (rendermesh_def->culling() != nullptr) {
for (size_t i = 0; i < rendermesh_def->culling()->size(); i++) {
int culling_test = rendermesh_def->culling()->Get(i);
assert(culling_test < CullingTest_Count);
rendermesh_data->culling_mask |= 1 << culling_test;
}
}
// TODO: Load this from a flatbuffer file instead of setting it.
rendermesh_data->tint = mathfu::kOnes4f;
}
void ABufferGeometryGLProcessor::geometryRender() {
ABUFFER_PROFILE("Total-Time");
// tempImage_ = new Image(outport_.getDimensions());
auto tempImage_ = outport_.getEditableData();
ImageGL* tempImageGL = tempImage_->getEditableRepresentation<ImageGL>();
ivec2 dim = outport_.getDimensions();
bool abufferEnabled = abuffer_.settings_.abufferEnable_.get();
// abuffer initialization
if (abufferEnabled) {
ABUFFER_PROFILE("Initialize-abuffer");
abuffer_.abuffer_initABuffer(dim, updateRequried_);
LGL_ERROR;
abuffer_.abuffer_addShaderDefinesAndBuild(&abuffer_.resolveABufferShader_);
LGL_ERROR;
ABUFFER_PROFILE("Reset-abuffer");
abuffer_.aBuffer_resetLinkList(tempImageGL);
updateRequried_ = false;
}
abuffer_.abuffer_addShaderDefinesAndBuild(&abufferGeometryShader_);
// Rendering
{
ABUFFER_PROFILE("Rendering");
tempImageGL = tempImage_->getEditableRepresentation<ImageGL>();
utilgl::activateAndClearTarget(outport_);
// initialize shader
abufferGeometryShader_.activate();
// LGL_ERROR;
utilgl::setShaderUniforms(abufferGeometryShader_, camera_, "camera_");
// LGL_ERROR;
utilgl::setShaderUniforms(abufferGeometryShader_, lightingProperty_, "light_");
// LGL_ERROR;
if (abufferEnabled) {
abuffer_.abuffer_addUniforms(&abufferGeometryShader_);
abufferGeometryShader_.setUniform("globalTransparency_", transparency_.get());
}
utilgl::GlBoolState depthTest(GL_DEPTH_TEST, true);
utilgl::CullFaceState culling(cullFace_.get());
utilgl::PolygonModeState polygon(polygonMode_.get(), renderLineWidth_, renderPointSize_);
for (auto& drawer : drawers_) {
utilgl::setShaderUniforms(abufferGeometryShader_, *(drawer.second->getGeometry()),
"geometry_");
drawer.second->draw();
}
abufferGeometryShader_.deactivate();
utilgl::deactivateCurrentTarget();
glMemoryBarrierEXT(GL_ALL_BARRIER_BITS_EXT);
}
// abuffer resolve
if (abufferEnabled) {
ABUFFER_PROFILE("Resolving-abuffer");
utilgl::activateAndClearTarget(outport_);
abuffer_.aBuffer_resolveLinkList(tempImageGL);
utilgl::deactivateCurrentTarget();
}
}
