#!/usr/bin/python3
# -*- coding: utf-8 -*-
# -*- mode: Python -*-


'''

example, based on custom
v0.1.0

A copy of square.py you can modify to code your plugin.
custom1 has necessary hooks in LJ.conf, webui and so on.


LICENCE : CC

by Sam Neurohack


'''
import sys
import os
ljpath = r'%s' % os.getcwd().replace('\\','/')

# import from shell
sys.path.append(ljpath +'/../../libs/')

#import from LJ
sys.path.append(ljpath +'/libs/')
print(ljpath+'/../libs/')

import lj23layers as lj

sys.path.append('../libs')
import math
import time
import argparse


print ("")
print ("Arguments parsing if needed...")
argsparser = argparse.ArgumentParser(description="Custom1 example for LJ")
argsparser.add_argument("-v","--verbose",help="Verbosity level (0 by default)",default=0,type=int)
args = argsparser.parse_args()

# Useful variables init.
white = lj.rgb2int(255,255,255)
red = lj.rgb2int(255,0,0)
blue = lj.rgb2int(0,0,255)
green = lj.rgb2int(0,255,0)

width = 800
height = 600
centerX = width / 2
centerY = height / 2

# 3D to 2D projection parameters
fov = 256
viewer_distance = 2.2

# Anaglyph computation parameters for right and left eyes.
# algorythm come from anaglyph geo maps 
eye_spacing = 100
nadir = 0.5
observer_altitude = 30000
map_layerane_altitude = 0.0

# square coordinates : vertices that compose each of the square.
vertices = [
        (- 1.0, 1.0,- 1.0),
        ( 1.0, 1.0,- 1.0),
        ( 1.0,- 1.0,- 1.0),
        (- 1.0,- 1.0,- 1.0)
        ]

face = [0,1,2,3]

#
# LJ inits
# 

layer = 0

# Define properties for each drawn "element" : name, intensity, active, xy, color, red, green, blue, layer , closed
Leftsquare = lj.FixedObject('Leftsquare', True, 255, [], red, 255, 0, 0, layer , True)
Rightsquare = lj.FixedObject('Rightsquare', True, 255, [], green, 0, 255, 0, layer , True)

# 'Destination' for given layer : name, number, active, layer , scene, laser
Dest0 = lj.DestObject('0', 0, True, 0 , 0, 0) 	# Dest0 will send layer 0 points to scene 0, laser 0 


#
# Anaglyph computation : different X coordinate for each eye
#

def LeftShift(elevation):

    diff = elevation - map_layerane_altitude
                        return nadir * eye_spacing *  diff / (observer_altitude - elevation)

def RightShift(elevation):

    diff = map_layerane_altitude - elevation
                        return (1 - nadir) * eye_spacing * diff / (observer_altitude - elevation)


def Proj(x,y,z,angleX,angleY,angleZ):

    rad = angleX * math.pi / 180
                cosa = math.cos(rad)
                sina = math.sin(rad)
                y2 = y
                y = y2 * cosa - z * sina
                z = y2 * sina + z * cosa

                rad = angleY * math.pi / 180
                cosa = math.cos(rad)
                sina = math.sin(rad)
                z2 = z
                z = z2 * cosa - x * sina
                x = z2 * sina + x * cosa

                rad = angleZ * math.pi / 180
                cosa = math.cos(rad)
                sina = math.sin(rad)
                x2 = x
                x = x2 * cosa - y * sina
                y = x2 * sina + y * cosa


                """ Transforms this 3D point to 2D using a perspective projection. """
                factor = fov / (viewer_distance + z)
                x = x * factor + centerX
                y = - y * factor + centerY
                return (x,y)


#
# Main 
#

def Run():
    Left = []
    Right = []
    counter =0
    try:
      while True: 
        Left = []
        Right = []
        x = vertices[0][0]
        y = vertices[0][1]
        z = vertices[0][2]

        # lj tracers will "move" the laser to this first point in black, then move to the next with second point color.
        # for more accuracy in dac emulator, repeat this first point.

        # generate all points in square.
        for point in face:
            x = vertices[point][0]
                y = vertices[point][1]
                z = vertices[point][2]
                left.append(proj(x+leftshift(z*25),y,z,0,counter,0))
                right.append(proj(x+rightshift(z*25),y,z,0,counter,0))	


        lj.polylineonecolor(left, c = leftsquare.color , layer = leftsquare.layer, closed = leftsquare.closed)
        lj.polylineonecolor(right, c = rightsquare.color , layer = rightsquare.layer, closed = rightsquare.closed)
        lj.drawdests()
        time.sleep(0.1)
        counter += 1
        if counter > 360:
            counter = 0

    except KeyboardInterrupt:
        pass

    # Gently stop on CTRL C
    finally:
        lj.ClosePlugin()


Run()