def prepareSceneRender(self):

        self.debug("Preparing scene render for", self._name)

        # Init buffer object
        self._createBuffer()

        # Prepare fullscreen quad
        self._quad = self._makeFullscreenQuad()

        # Prepare initial state
        cs = NodePath("InitialStateDummy")
        cs.setState(self._sourceCam.node().getInitialState())
        if self.hasTarget(RenderTargetType.Aux0):
            cs.setAttrib(AuxBitplaneAttrib.make(self._auxBits), 20)

        cs.setAttrib(StencilAttrib.makeOff(), 20)

        if not self._enableTransparency:
            cs.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone), 20)
        self._sourceCam.node().setInitialState(cs.getState())

        # Set new camera
        bufferCam = self._makeFullscreenCam()
        bufferCamNode = self._quad.attachNewNode(bufferCam)
        self._region.setCamera(bufferCamNode)
        self._region.setSort(5)

        # Set clears
        bufferRegion = self._buffer.getInternalBuffer().getDisplayRegion(0)

        self._correctClears()

        bufferRegion.setClearStencilActive(False)
        # self._sourceWindow.setClearStencilActive(False)

        # Set aux clears
        targetCheck = [
            (RenderTargetType.Aux0, GraphicsOutput.RTPAuxRgba0),
            (RenderTargetType.Aux1, GraphicsOutput.RTPAuxRgba1),
            (RenderTargetType.Aux2, GraphicsOutput.RTPAuxRgba2),
            (RenderTargetType.Aux3, GraphicsOutput.RTPAuxRgba3),
        ]
        for target, targetBindPos in targetCheck:
            if self.hasTarget(target):
                bufferRegion.setClearActive(targetBindPos, 1)
                bufferRegion.setClearValue(targetBindPos,
                                           Vec4(0.5, 0.5, 1.0, 0.0))

        self._region.disableClears()

        bufferRegion.setCamera(self._sourceCam)
        bufferRegion.setActive(1)
        # bufferRegion.setClearDepthActive(False)
        bufferRegion.setSort(20)

        self._setSizeShaderInput()
Beispiel #2
0
    def prepareSceneRender(self, earlyZ=False, earlyZCam=None):
        """ Renders the scene of the source camera to the buffer. See the
        documentation of this class for further information """

        self.debug("Preparing scene render")

        # Init buffer object
        self._createBuffer()

        # Prepare initial state
        cs = NodePath("InitialStateDummy")
        cs.setState(self._sourceCam.node().getInitialState())
        if self.hasTarget(RenderTargetType.Aux0):
            cs.setAttrib(AuxBitplaneAttrib.make(self._auxBits), 20)

        cs.setAttrib(StencilAttrib.makeOff(), 20)

        if not self._enableTransparency:
            cs.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone),
                         100)

        if not self._writeColor:
            cs.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 100)

        self._sourceCam.node().setInitialState(cs.getState())

        if earlyZ:
            self._earlyZRegion = self._internalBuffer.makeDisplayRegion()
            self._earlyZRegion.setSort(-10)
            self._earlyZRegion.setCamera(earlyZCam)

        self._node = NodePath("RTRoot")

        # Prepare fullscreen quad
        if self._createOverlayQuad:

            self._quad = self._makeFullscreenQuad()
            self._quad.reparentTo(self._node)

            bufferCam = self._makeFullscreenCam()
            self._camera = self._node.attachNewNode(bufferCam)
            self._region.setCamera(self._camera)
            self._region.setSort(5)

        # Set clears
        bufferRegion = self._internalBuffer.getDisplayRegion(0)
        self._correctClears()

        bufferRegion.setClearStencilActive(False)
        # self._sourceWindow.setClearStencilActive(False)

        # Set aux clears
        targetCheck = [
            (RenderTargetType.Aux0, GraphicsOutput.RTPAuxRgba0),
            (RenderTargetType.Aux1, GraphicsOutput.RTPAuxRgba1),
            (RenderTargetType.Aux2, GraphicsOutput.RTPAuxRgba2),
            (RenderTargetType.Aux3, GraphicsOutput.RTPAuxRgba3),
        ]
        for target, targetBindPos in targetCheck:
            if self.hasTarget(target):
                bufferRegion.setClearActive(targetBindPos, 1)
                bufferRegion.setClearValue(targetBindPos,
                                           Vec4(0.5, 0.5, 1.0, 0.0))

        self._region.disableClears()

        bufferRegion.setCamera(self._sourceCam)
        bufferRegion.setActive(1)
        bufferRegion.setClearDepthActive(False)
        bufferRegion.setSort(20)

        if earlyZ:
            self._earlyZRegion.disableClears()
            self._earlyZRegion.setClearDepthActive(True)
            self._earlyZRegion.setActive(1)

        self._setSizeShaderInput()

        self._active = True
        self._registerBuffer()
    def prepareSceneRender(self):
        """ Renders the scene of the source camera to the buffer. See the
        documentation of this class for further information """

        self.debug("Preparing scene render")

        # Init buffer object
        self._createBuffer()

        # Prepare fullscreen quad
        self._quad = self._makeFullscreenQuad()

        # Prepare initial state
        cs = NodePath("InitialStateDummy")
        cs.setState(self._sourceCam.node().getInitialState())
        if self.hasTarget(RenderTargetType.Aux0):
            cs.setAttrib(AuxBitplaneAttrib.make(self._auxBits), 20)

        cs.setAttrib(StencilAttrib.makeOff(), 20)

        if not self._enableTransparency:
            cs.setAttrib(TransparencyAttrib.make(TransparencyAttrib.MNone), 100)

        if not self._writeColor:
            cs.setAttrib(ColorWriteAttrib.make(ColorWriteAttrib.COff), 100)
            
        self._sourceCam.node().setInitialState(cs.getState())

        # Set new camera
        bufferCam = self._makeFullscreenCam()
        bufferCamNode = self._quad.attachNewNode(bufferCam)
        self._region.setCamera(bufferCamNode)
        self._region.setSort(5)

        # Set clears
        bufferRegion = self._buffer.getInternalBuffer().getDisplayRegion(0)

        self._correctClears()

        bufferRegion.setClearStencilActive(False)
        # self._sourceWindow.setClearStencilActive(False)

        # Set aux clears
        targetCheck = [
            (RenderTargetType.Aux0, GraphicsOutput.RTPAuxRgba0),
            (RenderTargetType.Aux1, GraphicsOutput.RTPAuxRgba1),
            (RenderTargetType.Aux2, GraphicsOutput.RTPAuxRgba2),
            (RenderTargetType.Aux3, GraphicsOutput.RTPAuxRgba3),
        ]
        for target, targetBindPos in targetCheck:
            if self.hasTarget(target):
                bufferRegion.setClearActive(targetBindPos, 1)
                bufferRegion.setClearValue(
                    targetBindPos, Vec4(0.5, 0.5, 1.0, 0.0))

        self._region.disableClears()

        bufferRegion.setCamera(self._sourceCam)
        bufferRegion.setActive(1)
        # bufferRegion.setClearDepthActive(False)
        bufferRegion.setSort(20)

        self._setSizeShaderInput()
Beispiel #4
0
loadPrcFileData('', "sync-video 0")
loadPrcFileData('', 'task-timer-verbose 1')
loadPrcFileData('', 'pstats-tasks 1')
loadPrcFileData('', 'want-pstats 1')
loadPrcFileData('', 'framebuffer-stencil 1')
#loadPrcFileData('', 'show-buffers 1')
#loadPrcFileData('', 'notify-level-glgsg debug')

import sandbox

import shapeGenerator

from panda3d.core import AmbientLight, ColorWriteAttrib, NodePath, Shader, StencilAttrib, Vec4

# Set up stenciling system
stencilReader = StencilAttrib.make(1,StencilAttrib.SCFEqual,StencilAttrib.SOKeep,
                       StencilAttrib.SOKeep,StencilAttrib.SOKeep,1,1,0)

constantOneStencil = StencilAttrib.make(1,StencilAttrib.SCFAlways,StencilAttrib.SOZero,
                       StencilAttrib.SOReplace,StencilAttrib.SOReplace,1,0,1)

#mesh = shapeGenerator.Tube(0.18, 0.18, 5.0, 32)
# To be render on texture
#inside_vortex = shapeGenerator.ShellCylinder(-0.18, 5.0, 32)
inside_vortex = shapeGenerator.Circle(0.18, 32)
inside_vortex.node().setAttrib(constantOneStencil)
inside_vortex.node().setAttrib(ColorWriteAttrib.make(0))
inside_vortex.setBin('background', 0)
inside_vortex.setDepthWrite(0)

#inside_vortex.setH(180)
inside_vortex.setP(180)
Beispiel #5
0
from math import floor

from sortedcontainers import SortedDict
from panda3d.core import NodePath, BitMask32, StencilAttrib

from terrain.chunk import Chunk
from terrain.pathfinder import PathFinder
from config import map_params
import config
from tiles import Empty
from towers import Center, Tower

constant_one_stencil = StencilAttrib.make(
    1, StencilAttrib.SCFAlways,
    StencilAttrib.SOZero, StencilAttrib.SOReplace,
    StencilAttrib.SOReplace, 1, 0, 1
)

stencil_reader = StencilAttrib.make(
    1, StencilAttrib.SCFEqual,
    StencilAttrib.SOKeep, StencilAttrib.SOKeep,
    StencilAttrib.SOKeep, 1, 1, 0
)


class Terrain:
    """The class holding the whole map."""

    def __init__(self, render, loader):
        self.chunk_map = SortedDict()
Beispiel #6
0
loadPrcFileData('', 'task-timer-verbose 1')
loadPrcFileData('', 'pstats-tasks 1')
loadPrcFileData('', 'want-pstats 1')
loadPrcFileData('', 'framebuffer-stencil 1')
#loadPrcFileData('', 'show-buffers 1')
#loadPrcFileData('', 'notify-level-glgsg debug')

import sandbox

import shapeGenerator

from panda3d.core import AmbientLight, ColorWriteAttrib, NodePath, Shader, StencilAttrib, Vec4

# Set up stenciling system
stencilReader = StencilAttrib.make(1, StencilAttrib.SCFEqual,
                                   StencilAttrib.SOKeep, StencilAttrib.SOKeep,
                                   StencilAttrib.SOKeep, 1, 1, 0)

constantOneStencil = StencilAttrib.make(1, StencilAttrib.SCFAlways,
                                        StencilAttrib.SOZero,
                                        StencilAttrib.SOReplace,
                                        StencilAttrib.SOReplace, 1, 0, 1)

#mesh = shapeGenerator.Tube(0.18, 0.18, 5.0, 32)
# To be render on texture
#inside_vortex = shapeGenerator.ShellCylinder(-0.18, 5.0, 32)
inside_vortex = shapeGenerator.Circle(0.18, 32)
inside_vortex.node().setAttrib(constantOneStencil)
inside_vortex.node().setAttrib(ColorWriteAttrib.make(0))
inside_vortex.setBin('background', 0)
inside_vortex.setDepthWrite(0)