Why render pipeline is very slow?

i see this topic


and this video

i have GTX 980 and panda3d have same performance, car sample run with 50fps max…
it’s pretty but…i don’t think it’s usable on a project (with more that 1 object like cars)

would you have a more consistent project example less how to use render pipeline with good performance?

RenderPipeline has a plugins configuration. So you can disable some plugins or change the settings of the specific plugin to get the better performance.

50fps is pretty good for a graphics pipeline that advanced. Keep in mind that it is a deferred pipeline, so most work is not actually spent rendering the car, but rather done in postprocessing. So, just because it’s rendering at 50fps doesn’t mean it’s going that the performance is going to drop to 25fps when you add a second car. It’s probably going to remain quite comfortably high until you add enough cars to overpower the bottleneck of the deferred processing.

And as Yonnji pointed out, the configuration can be changed in order to support older hardware better. The car model is also very detailed, so in an actual game you probably want a more optimised car model.

Ok,
what setting should I change in render pipeline to improve performance?

with this example, without make pipeline the program runs at 300fps in Full HD
but with render pipeline it falls to 30fps in full HD too

from __future__ import division
from math import pi, sin, cos


import sys
import math
import time

from panda3d.core import LVecBase2i, TransformState, RenderState, load_prc_file
from panda3d.core import PandaSystem, MaterialAttrib, WindowProperties
from panda3d.core import GeomTristrips, Vec4
from panda3d.core import Vec3, load_prc_file_data

from direct.showbase.ShowBase import ShowBase
from direct.stdpy.file import isfile
from panda3d.core import ShaderTerrainMesh, Shader, load_prc_file_data
 
from direct.showbase.ShowBase import ShowBase
from direct.task import Task
from direct.actor.Actor import Actor
from panda3d.core import loadPrcFile
from panda3d.core import SamplerState
from panda3d.core import NodePath, CardMaker, SamplerState

sys.path.insert(0, './RenderPipeline-master')

from rpcore import RenderPipeline
# This is a helper class for better camera movement - see below.
from rpcore.util.movement_controller import MovementController

 
loadPrcFile("./config.prc")
class MyApp(ShowBase):
def __init__(self):
    #ShowBase.__init__(self)
    
    self.render_pipeline = RenderPipeline()
    self.render_pipeline.create(self)
    
    dancer = Actor("dancer.egg.pz")
    dancer.setPos(0,0,0)
    chorusline = NodePath('chorusline')
    
    for i in range(50):
      placeholder = chorusline.attachNewNode("Dancer-Placeholder")
      placeholder.setPos(i*5,0,0)
      dancer.instanceTo(placeholder)
    for i in range(3):
      placeholder = render.attachNewNode("Line-Placeholder")
      placeholder.setPos(0,i*10,0)
      chorusline.instanceTo(placeholder)
  
app = MyApp()
app.run()

no people know solution ?

As Yonnji said, Render Pipeline has several plugins. Some of those have many costs although improving rendering quality. In my experience, I use only the following plugins:

ao, bloom, color_correction, forward_shading, pssm, scattering, sky_ao, env_probes

You can disable other plugins in “config/plugins.yaml” file.
And also, you can control some parameters for optimization in the file.

And Render Pipeline draws only dynamic lights and objects, not static.
So, all lights and objects can be movable, but the performance of rendering is decreased.
(You can find about “baking” technique for static lights or objects.)

Finally, as rdb pointed out, the complexity of the scene does not significantly affect performance by deferred pipeline. That is, differences of rendering time between the empty scene and the complex scene is similar in Panda3D or Render Pipeline.

p.s. I tested your codes in my system (GTX 1080, Full-HD), in Panda3D, empty scene is 0.142 ms and complex scene is 0.833 ms. In Render Pipeline, empty scene is 6.40 ms and complex scene is 7.20 ms.