class MouseDevice(avango.script.Script):
RelX = avango.SFFloat()
RelY = avango.SFFloat()
ButtonLeft = avango.SFBool()
ButtonRight = avango.SFBool()
def __init__(self):
self.super(MouseDevice).__init__()
self.device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.device_sensor.Station.value = "gua-device-mouse"
self.always_evaluate(True)
def evaluate(self):
self.RelX.value = 0.0
self.RelY.value = 0.0
rel_x = self.device_sensor.Value0.value
if rel_x >= 2 or rel_x <= -2:
self.RelX.value = rel_x
rel_y = self.device_sensor.Value1.value
if rel_y >= 2 or rel_y <= -2:
self.RelY.value = rel_y
self.ButtonLeft.value = self.device_sensor.Button0.value
self.ButtonRight.value = self.device_sensor.Button1.value
class Mover(avango.script.Script):
LeftTrigger = avango.SFBool()
RightTrigger = avango.SFBool()
UpTrigger = avango.SFBool()
DownTrigger = avango.SFBool()
ResetTrigger = avango.SFBool()
Matrix = avango.osg.SFMatrix()
def __init__(self):
self.super(Mover).__init__()
self._dist = 0.1
self.Matrix.value = avango.osg.make_ident_mat()
def evaluate(self):
if self.UpTrigger.value:
self.Matrix.value *= avango.osg.make_trans_mat(0, self._dist, 0)
if self.DownTrigger.value:
self.Matrix.value *= avango.osg.make_trans_mat(0, -self._dist, 0)
if self.LeftTrigger.value:
self.Matrix.value *= avango.osg.make_trans_mat(-self._dist, 0, 0)
if self.RightTrigger.value:
self.Matrix.value *= avango.osg.make_trans_mat(self._dist, 0, 0)
if self.ResetTrigger.value:
self.ResetTrigger.value = avango.osg.make_ident_mat()
class TUIOCursor(avango.script.Script):
PosX = avango.SFFloat()
PosY = avango.SFFloat()
SpeedX = avango.SFFloat()
SpeedY = avango.SFFloat()
MotionSpeed = avango.SFFloat()
MotionAcceleration = avango.SFFloat()
IsMoving = avango.SFBool()
State = avango.SFFloat()
SessionID = avango.SFFloat()
CursorID = avango.SFInt()
IsTouched = avango.SFBool()
MovementVector = avango.gua.SFVec2()
def __init__(self):
self.super(TUIOCursor).__init__()
# initialize fields
self.PosX.value = -1.0
self.PosY.value = -1.0
self.State.value = 4.0
self.SessionID.value = -1.0
self.MovementVector.value = avango.gua.Vec2(0, 0)
self.device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.PosX.connect_from(self.device_sensor.Value0)
self.PosY.connect_from(self.device_sensor.Value1)
self.SpeedX.connect_from(self.device_sensor.Value2)
self.SpeedY.connect_from(self.device_sensor.Value3)
self.MotionSpeed.connect_from(self.device_sensor.Value4)
self.MotionAcceleration.connect_from(self.device_sensor.Value5)
self.IsMoving.connect_from(self.device_sensor.Value6)
self.State.connect_from(self.device_sensor.Value7)
self.SessionID.connect_from(self.device_sensor.Value8)
def updateTouched(self):
"""
Call whenever some touch input data has changed. This method will update self.IsTouched accordingly.
"""
self.IsTouched.value = (self.PosX.value != -1.0
and self.PosY.value != -1.0)
@field_has_changed(CursorID)
def set_station(self):
"""
Set station name.
"""
self.device_sensor.Station.value = "gua-finger{}#cursor".format(
self.CursorID.value)
@field_has_changed(PosX)
def updatePosX(self):
self.updateTouched()
@field_has_changed(PosY)
def updatePosY(self):
self.updateTouched()
class PropertyModifierInt(avango.script.Script):
Enable = avango.SFBool()
TimeIn = avango.SFDouble()
Property = avango.SFInt()
PropertyMin = avango.SFInt()
PropertyMax = avango.SFInt()
PropertyStepSize = avango.SFInt()
PropertyInc = avango.SFBool()
PropertyDec = avango.SFBool()
TriggerTimeDelta = avango.SFFloat()
Triggered = avango.SFBool()
def __init__(self):
self.super(PropertyModifierInt).__init__()
self.last_trigger_time = self.TimeIn.value
self.Enable.value = False
self.Property.value = 0
self.PropertyMin.value = 0
self.PropertyMax.value = 100000
self.PropertyStepSize.value = 1
self.PropertyInc.value = False
self.PropertyDec.value = False
self.TriggerTimeDelta.value = 0.05
self.always_evaluate(True)
self.Name.value = "PropertyModifierInt"
def evaluate(self):
if (not self.PropertyInc.value
and not self.PropertyDec.value) or not self.Enable.value:
return
time = self.TimeIn.value
time_delta = time - self.last_trigger_time
if time_delta > self.TriggerTimeDelta.value:
if self.PropertyInc.value:
new_val = self.Property.value + self.PropertyStepSize.value
if new_val <= self.PropertyMax.value:
self.Property.value = new_val
self.Triggered.value = True
self.last_trigger_time = time
elif self.PropertyDec.value:
new_val = self.Property.value - self.PropertyStepSize.value
if new_val >= self.PropertyMin.value:
self.Property.value = new_val
self.Triggered.value = True
self.last_trigger_time = time
class Toggler(avango.script.Script):
EnableOut = avango.SFBool()
KeyIn = avango.SFBool()
def __init__(self):
self.super(Toggler).__init__()
self.key_in = False
def evaluate(self):
if self.KeyIn.value is True and self.key_in is False:
print("toggle Segmentation")
self.EnableOut.value = not self.EnableOut.value
self.key_in = self.KeyIn.value
class PointerInput(avango.script.Script):
## input fields
sf_button0 = avango.SFBool()
sf_toggle_button = avango.SFBool()
sf_pointer_mat = avango.gua.SFMatrix4()
## Default constructor.
def __init__(self):
self.super(PointerInput).__init__()
def init_art_pointer(self, POINTER_TRACKING_STATION,
TRACKING_TRANSMITTER_OFFSET, POINTER_DEVICE_STATION,
KEYBOARD_STATION):
## init sensors
self.pointer_tracking_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.pointer_tracking_sensor.Station.value = POINTER_TRACKING_STATION
self.pointer_tracking_sensor.TransmitterOffset.value = TRACKING_TRANSMITTER_OFFSET
self.pointer_tracking_sensor.ReceiverOffset.value = avango.gua.make_trans_mat(
0.0, 0.0, -0.1)
self.pointer_device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.pointer_device_sensor.Station.value = POINTER_DEVICE_STATION
self.keyboard_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.keyboard_sensor.Station.value = KEYBOARD_STATION
### init field connections
self.sf_button0.connect_from(self.pointer_device_sensor.Button0)
self.sf_toggle_button.connect_from(self.keyboard_sensor.Button16)
self.sf_pointer_mat.connect_from(self.pointer_tracking_sensor.Matrix)
def init_vive_pointer(self, TRACKING_NAME_BASE):
## init sensors
self.hmd_service = avango.daemon.DeviceService()
self.hmd_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=self.hmd_service)
self.hmd_sensor.Station.value = TRACKING_NAME_BASE + "-0"
self.controller1_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=self.hmd_service)
self.controller1_sensor.Station.value = TRACKING_NAME_BASE + "-1"
### init field connections
self.sf_button0.connect_from(self.controller1_sensor.Button4)
self.sf_toggle_button.connect_from(self.controller1_sensor.Button2)
self.sf_pointer_mat.connect_from(self.controller1_sensor.Matrix)
class MouseListener(avango.script.Script):
MousePosNorm = avango.osg.SFVec2()
MousePos = avango.osg.SFVec2()
MouseButtonLeft = avango.SFBool()
MouseButtonRight = avango.SFBool()
def __init__(self):
self.super(MouseListener).__init__()
self.Name.value = "MouseListener"
def evaluate(self):
buffer = field_dump(self)
print buffer
class TeleportNavigation(NavigationTechnique):
### fields ###
## input fields
sf_pointer_button = avango.SFBool()
### constructor
def __init__(self):
NavigationTechnique.__init__(self) # call base class constructor
def my_constructor(self, NAVIGATION_MANAGER, SCENEGRAPH):
### external references ###
self.NAVIGATION_MANAGER = NAVIGATION_MANAGER
self.sf_pointer_button.connect_from(
self.NAVIGATION_MANAGER.INPUTS.sf_pointer_button)
self.always_evaluate(True) # change global evaluation policy
### callback functions ###
def evaluate(self): # implement respective base-class function
if self.enable_flag == False:
return
class SceneScript(avango.script.Script):
## input fields
sf_reset_button = avango.SFBool()
## Default constructor.
def __init__(self):
self.super(SceneScript).__init__()
### external references ###
self.CLASS = None # is set later
### resources ###
self.keyboard_device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.keyboard_device_sensor.Station.value = "gua-device-keyboard0"
self.sf_reset_button.connect_from(
self.keyboard_device_sensor.Button14) # spacebar key
def my_constructor(self, CLASS):
self.CLASS = CLASS
### callbacks ###
@field_has_changed(sf_reset_button)
def sf_reset_button_changed(self):
if self.sf_reset_button.value == True and self.CLASS is not None: # button pressed
self.CLASS.reset()
class FPSToggler(avango.script.Script):
# input field
sf_fps_toggle = avango.SFBool()
sf_fps_toggle.value = False
def __init__(self):
self.super(FPSToggler).__init__()
self.viewer = None
# init keyboard sensor for fps toggle
self.device_service = avango.daemon.DeviceService()
self.keyboard_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=self.device_service)
self.keyboard_sensor.Station.value = 'gua-device-keyboard'
self.sf_fps_toggle.connect_from(self.keyboard_sensor.Button4)
# sets the viewer on which fps changes are to be toggled
def set_viewer(self, viewer):
self.viewer = viewer
# called whenever sf_fps_toggle changes
@field_has_changed(sf_fps_toggle)
def sf_fps_toggle_changed(self):
if self.sf_fps_toggle.value and self.viewer is not None:
if self.viewer.DesiredFPS.value > 20.0:
print("Slow framerate activated")
self.viewer.DesiredFPS.value = 20.0
else:
print("Normal framerate activated")
self.viewer.DesiredFPS.value = 250.0
class ImmediateEdgeTrigger(avango.script.Script):
"""
Triggers immediately (as soon as the field has been changed) on
the edge transitions of the value of the Trigger field.
"""
Trigger = avango.SFBool()
def __init__(self):
self.super(ImmediateEdgeTrigger).__init__()
self._last_trigger = False
self.Name.value = "ImmediateEdgeTrigger"
@field_has_changed(Trigger)
def trigger_changed(self):
callback = None
if self.Trigger.value:
if not self._last_trigger:
self._last_trigger = True
self.on_down_transition()
else:
if self._last_trigger:
self._last_trigger = False
self.on_up_transition()
def on_up_transition(self):
pass
def on_down_transition(self):
pass
class EdgeTrigger(avango.script.Script):
"Triggers on the edge transitions of the value of the Trigger field."
Trigger = avango.SFBool()
def __init__(self):
self.super(EdgeTrigger).__init__()
self._last_trigger = False
self.Name.value = "EdgeTrigger"
def evaluate(self):
callback = None
if self.Trigger.value:
if not self._last_trigger:
self._last_trigger = True
self.on_down_transition()
else:
if self._last_trigger:
self._last_trigger = False
self.on_up_transition()
def on_up_transition(self):
pass
def on_down_transition(self):
pass
class KeyMonitorTrigger(EdgeTrigger):
Released = avango.SFBool()
Pressed = avango.SFBool()
def __init__(self):
self.super(KeyMonitorTrigger).__init__()
self.Name.value = "KeyMonitorTrigger"
def on_up_transition(self):
self.Pressed.value = False
self.Released.value = True
def on_down_transition(self):
self.Pressed.value = True
self.Released.value = False
class RadiusRumbler(avango.script.Script):
Trigger = avango.SFBool()
Radius = avango.SFFloat()
def __init__(self):
self.super(RadiusRumbler).__init__()
self._rad_delta = 0.02
self._enlarge = True
@field_has_changed(Trigger)
def trigger_changed(self):
if self.Trigger.value:
self.always_evaluate(True)
else:
self.always_evaluate(False)
def evaluate(self):
if self.Trigger.value:
delta = self._rad_delta
if not self._enlarge:
delta = -delta
self.Radius.value += delta
self._enlarge = not self._enlarge
class SceneManager(avango.script.Script):
## input fields
sf_reset_button = avango.SFBool()
sf_scene1_button = avango.SFBool()
sf_scene2_button = avango.SFBool()
## Default constructor.
def __init__(self):
self.super(SceneManager).__init__()
### resources ###
self.keyboard_device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.keyboard_device_sensor.Station.value = "device-keyboard"
## init field connections
self.sf_reset_button.connect_from(
self.keyboard_device_sensor.Button18) # spacebar key
self.sf_scene1_button.connect_from(
self.keyboard_device_sensor.Button12) # key 1
self.sf_scene2_button.connect_from(
self.keyboard_device_sensor.Button13) # key 2
def my_constructor(self, PARENT_NODE=None):
## init scenes
self.scene1 = Scene1(PARENT_NODE=PARENT_NODE)
self.scene2 = Scene2(PARENT_NODE=PARENT_NODE)
self.scene1.enable(True)
### callback functions ###
@field_has_changed(sf_scene1_button)
def sf_scene1_button_changed(self):
if self.sf_scene1_button.value == True: # button pressed
self.scene1.enable(True)
self.scene2.enable(False)
@field_has_changed(sf_scene2_button)
def sf_scene2_button_changed(self):
if self.sf_scene2_button.value == True: # button pressed
self.scene1.enable(False)
self.scene2.enable(True)
'''
class User(avango.script.Script):
Active = avango.SFBool()
Matrix = avango.gua.SFMatrix4()
ViewerMatrix = avango.gua.SFMatrix4()
def __init__(self):
self.super(User).__init__()
self.Active.value = True
class ColorFader(avango.script.Script):
StartColor = avango.gua.SFVec4()
EndColor = avango.gua.SFVec4()
Duration = avango.SFFloat()
StartFade = avango.SFBool()
FadeFinished = avango.SFBool()
RawInterpolatedValue = avango.SFFloat()
Color = avango.gua.SFVec4()
def __init__(self):
self.super(ColorFader).__init__()
self.StartFade.value = False
self.FadeFinished.value = False
self.Color.value = avango.gua.Vec4(1,1,1,1)
self.__interpolator_running = True
self.__interpolator = Interpolator()
self.__interpolator.MinVal.value = 0.0
self.__interpolator.MaxVal.value = 1.0
self.__interpolator.Duration.connect_from(self.Duration)
self.__interpolator.Start.connect_from(self.StartFade)
self.FadeFinished.connect_from(self.__interpolator.Finished)
self.RawInterpolatedValue.connect_weak_from(self.__interpolator.Value)
self.Name.value = "ColorFader"
@field_has_changed(StartFade)
def start_changed(self):
self.__interpolator_running = True
@field_has_changed(FadeFinished)
def fade_finished_changed(self):
self.__interpolator_running = False
def evaluate(self):
if self.__interpolator_running:
val = self.RawInterpolatedValue.value
self.Color.value = mix_color(self.EndColor.value,self.StartColor.value,val)
class KeyToggleTrigger(EdgeTrigger):
Toggle = avango.SFBool()
def __init__(self):
self.super(KeyToggleTrigger).__init__()
self.Name.value = "KeyToggleTrigger"
def on_up_transition(self):
self.Toggle.value = True
class TeleportNavigation(NavigationTechnique):
### fields ###
## input fields
teleportation_matrix = None
sf_pointer_button = avango.SFBool()
flag = False
### constructor
def __init__(self):
NavigationTechnique.__init__(self) # call base class constructor
def my_constructor(self, NAVIGATION_MANAGER, SCENEGRAPH):
### external references ###
self.NAVIGATION_MANAGER = NAVIGATION_MANAGER
self.sf_pointer_button.connect_from(
self.NAVIGATION_MANAGER.INPUTS.sf_pointer_button)
self.always_evaluate(True) # change global evaluation policy
### callback functions ###
def evaluate(self): # implement respective base-class function
if self.enable_flag == False:
self.NAVIGATION_MANAGER.ray_geometry.Tags.value = ["invisible"]
self.teleportation_matrix = None
return
## To-Do: realize Teleport navigation here
if (self.sf_pointer_button.value == True and self.flag == False):
self.flag = True
self.hit_point = self.NAVIGATION_MANAGER.intersection_geometry.WorldTransform.value.get_translate(
)
if (self.sf_pointer_button.value == False and self.flag == True):
self.flag = False
self.teleportation_matrix = avango.gua.make_trans_mat(
self.hit_point)
#nav_matrix = self.NAVIGATION_MANAGER.get_navigation_matrix()
offset_x = -self.NAVIGATION_MANAGER.get_head_matrix(
).get_translate().x
offset_z = -self.NAVIGATION_MANAGER.get_head_matrix(
).get_translate().z
offset = avango.gua.make_trans_mat(offset_x, 0, offset_z)
self.NAVIGATION_MANAGER.set_navigation_matrix(
self.teleportation_matrix * offset)
self.teleportation_matrix = None
self.NAVIGATION_MANAGER.ray_geometry.Tags.value = []
self.NAVIGATION_MANAGER.calc_pick_result()
self.NAVIGATION_MANAGER.update_ray_visualization()
class PointerDevice(avango.script.Script):
sf_key_pageup = avango.SFBool()
sf_key_pagedown = avango.SFBool()
def __init__(self):
self.super(PointerDevice).__init__()
def my_constructor(self,NAME):
self.device_sensor = avango.daemon.nodes.DeviceSensor(DeviceService = avango.daemon.DeviceService())
self.device_sensor.Station.value = "device-pointer_" + NAME
if (NAME =="MOUSE USB MOUSE"):
self.sf_key_pageup.connect_from(self.device_sensor.Button0)
self.sf_key_pagedown.connect_from(self.device_sensor.Button1)
if (NAME == "2.4G Presenter"):
self.sf_key_pageup.connect_from(self.device_sensor.Button3)
self.sf_key_pagedown.connect_from(self.device_sensor.Button4)
class LightToolScript(avango.script.Script):
### internal fields ###
sf_button0 = avango.SFBool()
sf_button1 = avango.SFBool()
### Default constructor.
def __init__(self):
self.super(LightToolScript).__init__()
self.CLASS = None
def my_constructor(self, CLASS):
### references ###
self.CLASS = CLASS
## Called whenever sf_button0 changes.
@field_has_changed(sf_button0)
def sf_button0_changed(self):
if self.CLASS is not None:
self.CLASS.process_button0(self.sf_button0.value)
class MonitorView(avango.script.Script):
BoundingSphereRoot = avango.osg.SFNode()
TransformAndScaleNode = avango.osg.SFMatrixTransform()
ToggleFullScreen = avango.SFBool()
WindowDecoration = avango.SFBool()
EnableTrackball = avango.SFBool()
Root = avango.osg.SFNode()
Camera = avango.osg.SFMatrix()
Viewport = avango.osg.SFVec4()
Depth = avango.SFFloat()
UserSelector = avango.SFInt()
Near = avango.SFFloat()
Far = avango.SFFloat()
BackgroundColor = avango.osg.SFVec4()
def __init__(self):
self.super(MonitorView).__init__()
bounding_sphere_root = avango.osg.nodes.BoundingBoxCalculator()
self.TransformAndScaleNode.value = avango.osg.nodes.MatrixTransform()
bounding_sphere_root.Children.value.append(
self.TransformAndScaleNode.value)
self.BoundingSphereRoot.value = bounding_sphere_root
self.WindowDecoration.value = True
self.EnableTrackball.value = False
self.Viewport.value = avango.osg.Vec4(0, 0, 1, 1)
self.Depth.value = 0
self.Near.value = 0.1
self.Far.value = 500.
self.BackgroundColor.value = avango.osg.Vec4(0., 0., 0., 1.)
self.UserSelector.value = 0
@field_has_changed(Root)
def root_has_changed(self):
self.TransformAndScaleNode.value.Children.value = [self.Root.value]
class KeyToggleTriggerAlternate(EdgeTrigger):
Toggle = avango.SFBool()
def __init__(self):
self.super(KeyToggleTriggerAlternate).__init__()
self.Name.value = "KeyToggleTriggerAlternate"
def init(self, initial_state):
self.Toggle.value = initial_state
def on_up_transition(self):
self.Toggle.value = not self.Toggle.value
class RandomColor(avango.script.Script):
# input field
Trigger = avango.SFBool()
# output field
ColorOut = avango.gua.SFColor()
def evaluate(self):
if self.Trigger.value: # only update color on button down
self.ColorOut.value = avango.gua.Color(0.5 * random(),
0.5 * random(),
0.5 * random())
def add_and_connect_bool_field(self, field):
field_name = self.BaseFieldName.value + str(self._actual_id)
if self.has_field(field_name):
return
#create and add the new field
self.add_and_init_field(avango.SFBool(), field_name, False)
#connect the field with the given field
getattr(self, field_name).connect_from(field)
self._actual_id += 1
self.NumFieldsIn.value = self._actual_id
class TeleportNavigation(NavigationTechnique):
### fields ###
## input fields
sf_pointer_button = avango.SFBool()
### constructor
def __init__(self):
NavigationTechnique.__init__(self) # call base class constructor
def my_constructor(self, NAVIGATION_MANAGER, SCENEGRAPH):
### external references ###
self.NAVIGATION_MANAGER = NAVIGATION_MANAGER
self.sf_pointer_button.connect_from(
self.NAVIGATION_MANAGER.INPUTS.sf_pointer_button)
self.always_evaluate(True) # change global evaluation policy
pointer_button_pressed = False
### callback functions ###
def evaluate(self): # implement respective base-class function
## To-Do: realize Teleport navigation here
# Get the values from intersection
self.NAVIGATION_MANAGER.calc_pick_result()
# render ray cast
self.NAVIGATION_MANAGER.update_ray_visualization()
# apply teleportation whe button pressed
if self.sf_pointer_button.value and not self.pointer_button_pressed:
self.pointer_button_pressed = True
_head_rot_mat = avango.gua.make_rot_mat(
self.NAVIGATION_MANAGER.VIEWING_SETUP.navigation_node.
WorldTransform.value.get_rotate())
_vec3_intersection_trans = self.NAVIGATION_MANAGER.intersection_geometry.WorldTransform.value.get_translate(
)
_new_trans_mat = avango.gua.make_trans_mat(
_vec3_intersection_trans) * _head_rot_mat
self.NAVIGATION_MANAGER.set_navigation_matrix(_new_trans_mat)
elif self.sf_pointer_button.value == False:
self.pointer_button_pressed = False
class TouchCursor(avango.script.Script):
CursorID = avango.SFInt()
PosX = avango.SFFloat()
PosY = avango.SFFloat()
SpeedX = avango.SFFloat()
SpeedY = avango.SFFloat()
MotionSpeed = avango.SFFloat()
MotionAcceleration = avango.SFFloat()
IsMoving = avango.SFBool()
State = avango.SFInt()
SessionID = avango.SFInt()
def __init__(self):
self.super(TouchCursor).__init__()
self.__device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.PosX.value = -1
self.PosY.value = -1
self.always_evaluate(True)
@field_has_changed(CursorID)
def set_station(self):
self.__device_sensor.Station.value = "gua-finger" + str(
self.CursorID.value)
def evaluate(self):
self.PosX.value = self.__device_sensor.Value0.value
self.PosY.value = self.__device_sensor.Value1.value
self.SpeedX.value = self.__device_sensor.Value2.value
self.SpeedY.value = self.__device_sensor.Value3.value
self.MotionSpeed.value = self.__device_sensor.Value4.value
self.MotionAcceleration.value = self.__device_sensor.Value5.value
self.IsMoving.value = bool(self.__device_sensor.Value6.value)
self.State.value = int(self.__device_sensor.Value7.value)
self.SessionID.value = int(self.__device_sensor.Value8.value)
class SceneScript(avango.script.Script):
## input fields
sf_reset_button = avango.SFBool()
## Default constructor.
def __init__(self):
self.super(SceneScript).__init__()
### external references ###
self.CLASS = None # is set later
### resources ###
self.keyboard_device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.keyboard_device_sensor.Station.value = "gua-device-keyboard0"
self.sf_reset_button.connect_from(
self.keyboard_device_sensor.Button14) # spacebar key
self.tempo = None
self.always_evaluate(True)
def my_constructor(self, CLASS):
self.CLASS = CLASS
### callbacks ###
@field_has_changed(sf_reset_button)
def sf_reset_button_changed(self):
if self.sf_reset_button.value == True and self.CLASS is not None: # button pressed
self.CLASS.reset()
@staticmethod
def get_rotation_for_time(time):
return avango.gua.make_rot_mat(2 * math.degrees(time % math.pi), 0.0,
1.0, 0.0)
def set_tempo(self, tempo):
self.tempo = tempo
def evaluate(self):
if self.tempo is not None:
_trans_mat = avango.gua.make_trans_mat(0.0, 0.05, 0.5)
_rot_mat = self.get_rotation_for_time(time.time())
_scale_mat = avango.gua.make_scale_mat(
self.tempo.Transform.value.get_scale())
self.tempo.Transform.value = _rot_mat * _trans_mat * _scale_mat
def add_key(self, name, id):
"""
Add a SFBool, which will be connected to the key press with the given id
The naming convention says that you should pass Key<Name> as name parameter.
E.g.: If you want to add the key <1> call add_key("Key1",48)
"""
#if a field with the given name is already known, no new field will be added
field = self._get_field(name)
if field:
return False
self.add_and_init_field(avango.SFBool(), name, id)
self.__keymap[id] = getattr(self, name)
self.__keymap[id].value = False
return True
class Device(avango.script.Script):
Active = avango.SFBool()
Matrix = avango.gua.SFMatrix4()
Button1 = avango.SFBool()
Button2 = avango.SFBool()
Button3 = avango.SFBool()
Button4 = avango.SFBool()
Button5 = avango.SFBool()
def __init__(self):
self.super(Device).__init__()
self.Active.value = True
