from panda3d.core import *
import sys,os
loadPrcFileData("", 'show-frame-rate-meter #t')
loadPrcFileData("", 'basic-shaders-only #t')

import direct.directbase.DirectStart
from direct.filter.CommonFilters import *
from direct.interval.IntervalGlobal import *
from direct.gui.DirectGui import OnscreenText
from direct.showbase.DirectObject import DirectObject
from direct.actor import Actor
from random import *
from math import sin

# Function to put instructions on the screen.
def addInstructions(pos, msg):
    return OnscreenText(text=msg, style=1, fg=(1,1,1,1), mayChange=1,
                        pos=(-1.3, pos), align=TextNode.ALeft, scale = .05, shadow=(0,0,0,1), shadowOffset=(0.1,0.1))

# Function to put title on the screen.
def addTitle(text):
    return OnscreenText(text=text, style=1, fg=(1,1,1,1),
                        pos=(1.3,-0.95), align=TextNode.ARight, scale = .07)

class World(DirectObject):
    def __init__(self):

        # Preliminary capabilities check.

        if (base.win.getGsg().getSupportsBasicShaders()==0):
            self.t=addTitle("Shadow Demo: Video driver reports that shaders are not supported.")
            return
        if (base.win.getGsg().getSupportsDepthTexture()==0):
            self.t=addTitle("Shadow Demo: Video driver reports that depth textures are not supported.")
            return

        self.inst_p = addInstructions(0.95, 'P : stop/start the Panda Rotation')
        self.inst_w = addInstructions(0.90, 'W : stop/start the Walk Cycle')
        self.inst_t = addInstructions(0.85, 'T : stop/start the Teapot')
        self.inst_l = addInstructions(0.80, 'L : move light source far or close')
        self.inst_v = addInstructions(0.75, 'V: View the Depth-Texture results')
        self.inst_x = addInstructions(0.70, 'Left/Right Arrow : switch camera angles')
        self.inst_a = addInstructions(0.65, 'Something about A/Z and push bias')

        base.setBackgroundColor(0,0,0.2,1)

        base.camLens.setNearFar(0.5, 400)
        base.camLens.setFov(75)
        #base.disableMouse()

        # Load the scene.

        floorTex=loader.loadTexture('maps/envir-ground.jpg')
        cm=CardMaker('')
        cm.setFrame(-2,2,-2,2)
        floor = render.attachNewNode(PandaNode("floor"))
        for y in range(12):
            for x in range(12):
                nn = floor.attachNewNode(cm.generate())
                nn.setP(-90)
                nn.setPos((x-6)*4, (y-6)*4, 0)
        floor.setTexture(floorTex)
        floor.flattenStrong()

        dlight = DirectionalLight("dlight")
        dlightNode = render.attachNewNode(dlight)
        dlightNode.setHpr(30, 50, 0)
        dlight.setColor(VBase4(0.9, 0.9, 0.9, 1.4))
        render.setLight(dlightNode)

        alight = AmbientLight("alight")
        alightNode = render.attachNewNode(alight)
        render.setLight(alightNode)

        self.pandaAxis = render.attachNewNode('panda axis')
        self.pandaModel = Actor.Actor('panda-model',{'walk':'panda-walk4'})
        self.pandaModel.reparentTo(self.pandaAxis)
        self.pandaModel.setPos(9,0,0)
        self.pandaModel.setScale(0.01, 0.01, 0.01)
        self.pandaModel.setShaderInput("scale",0.01,0.01,0.01,0.01)
        self.pandaWalk = self.pandaModel.actorInterval('walk',playRate=1.8)
        self.pandaWalk.loop()
        self.pandaMovement = self.pandaAxis.hprInterval(20.0,Point3(-360,0,0),startHpr=Point3(0,0,0))
        self.pandaMovement.loop()

        self.teapot = loader.loadModel('src/data/avatar.egg')
        self.teapot.reparentTo(render)
        self.teapot.setPos(0,-20,10)
        self.teapotMovement = self.teapot.hprInterval(50,Point3(0,360,360))
        self.teapotMovement.loop()

        brick1 = loader.loadModel('src/data/brick-flat.egg')
        brick1.reparentTo(render)
        brick1.setPos(10, -20, 5)
        brick1.setColor(0.2, 0.1, 0.5)

        brick1 = loader.loadModel('src/data/brick-flat.egg')
        brick1.reparentTo(render)
        brick1.setPos(10, -20, 7)
        brick1.setColor(0.3, 0.4, 0.1)
        brick1.setScale(0.5, 0.5, 1)

        self.accept('escape',sys.exit)

        self.accept("arrow_left", self.incrementCameraPosition, [-1])
        self.accept("arrow_right", self.incrementCameraPosition, [1])
        self.accept("p", self.toggleInterval, [self.pandaMovement])
        self.accept("P", self.toggleInterval, [self.pandaMovement])
        self.accept("t", self.toggleInterval, [self.teapotMovement])
        self.accept("T", self.toggleInterval, [self.teapotMovement])
        self.accept("w", self.toggleInterval, [self.pandaWalk])
        self.accept("W", self.toggleInterval, [self.pandaWalk])
        self.accept("v", base.bufferViewer.toggleEnable)
        self.accept("V", base.bufferViewer.toggleEnable)
        self.accept("o", base.oobe)

        depthnormalBuffer = base.win.makeTextureBuffer("depth-and-normal-buffer", 512, 512)
        depthnormalCamera = base.makeCamera(depthnormalBuffer, lens=base.cam.node().getLens())
        depthnormalCamera.node().setScene(render)
        tempnode = NodePath(PandaNode("temp node"))
        tempnode.setShader(loader.loadShader("synth-depthandnormals.cg"))
        depthnormalCamera.node().setInitialState(tempnode.getState())

        random_normals = loader.loadTexture("noise.png")

        cm = CardMaker("filter-stage-quad")
        cm.setFrameFullscreenQuad()
        cm.setColor(0, 0, 0, 0)
        quad = NodePath(cm.generate())
        quad.setDepthTest(0)
        quad.setDepthWrite(0)
        quad.setTransparency(TransparencyAttrib.MAlpha)
        quad.setShader(Shader.load('ssao-singlebuffer.cg'))
        quad.setShaderInput('buffer', depthnormalBuffer.getTexture())
        quad.setShaderInput('random', random_normals)

        aoBuffer=base.win.makeTextureBuffer("aoBuffer", 256, 256)
        self.aoBuffer=aoBuffer

        quadcamnode = Camera("filter-quad-cam")
        lens = OrthographicLens()
        lens.setFilmSize(2, 2)
        lens.setFilmOffset(0, 0)
        lens.setNearFar(-1000, 1000)
        quadcamnode.setLens(lens)
        quadcam = quad.attachNewNode(quadcamnode)

        aoBuffer.getDisplayRegion(0).setCamera(quadcam)
        aoBuffer.getDisplayRegion(0).setActive(1)

        ssao_renderer = NodePath(cm.generate())
        ssao_renderer.setColor(1, 1, 1, 0)
        ssao_renderer.setDepthTest(0)
        ssao_renderer.setDepthWrite(0)
        ssao_renderer.reparentTo(render2d)
        ssao_renderer.setTransparency(TransparencyAttrib.MAlpha)
        Zssao_renderer.setShader(Shader.load('ssao-render.cg'))
        ssao_renderer.setShaderInput('ssaotex', aoBuffer.getTexture())

        filter_manager = CommonFilters(aoBuffer, quadcam)
        filter_manager.setBlurSharpen(0.05)


# end of __init__

    def toggleInterval(self, ival):
        if (ival.isPlaying()):
            ival.pause()
        else:
            ival.resume()

    def incrementCameraPosition(self,n):
        self.cameraSelection = (self.cameraSelection + n) % 6
        if (self.cameraSelection == 0):
            base.cam.reparentTo(render)
            base.cam.setPos(30,-45,26)
            base.cam.lookAt(0,0,0)
        if (self.cameraSelection == 1):
            base.cam.reparentTo(self.pandaModel)
            base.cam.setPos(7,-3,9)
            base.cam.lookAt(0,0,0)
        if (self.cameraSelection == 2):
            base.cam.reparentTo(self.pandaModel)
            base.cam.setPos(-7,-3,9)
            base.cam.lookAt(0,0,0)
        if (self.cameraSelection == 3):
            base.cam.reparentTo(render)
            base.cam.setPos(7,-23,12)
            base.cam.lookAt(self.teapot)
        if (self.cameraSelection == 4):
            base.cam.reparentTo(render)
            base.cam.setPos(-7,-23,12)
            base.cam.lookAt(self.teapot)
        if (self.cameraSelection == 5):
            base.cam.reparentTo(render)
            base.cam.setPos(1000,0,195)
            base.cam.lookAt(0,0,0)

    def incrementLightPosition(self,n):
        self.lightSelection = (self.lightSelection + n) % 2
        if (self.lightSelection == 0):
            self.LCam.setPos(0,-40,25)
            self.LCam.lookAt(0,-10,0)
            self.LCam.node().getLens().setNearFar(10,100)
        if (self.lightSelection == 1):
            self.LCam.setPos(0,-600,200)
            self.LCam.lookAt(0,-10,0)
            self.LCam.node().getLens().setNearFar(10,1000)

    def shaderSupported(self):
        return base.win.getGsg().getSupportsBasicShaders()

    def adjustPushBias(self,inc):
        self.pushBias *= inc
        self.inst_a.setText('A/Z: Increase/Decrease the Push-Bias [%F]' % self.pushBias)
        render.setShaderInput('push',self.pushBias,self.pushBias,self.pushBias,0)


World()
run()