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 A(avango.script.Script):
Field1 = avango.SFInt()
Field2 = avango.SFInt()
Field3 = avango.SFInt()
def __init__(self):
self.super(A).__init__()
self.Field1.value = 0
self.Field2.value = 0
self.Field3.value = 0
class TimeDeltaIncrement(avango.utils.TaskSchedulerTask):
Delta = avango.SFInt()
Value = avango.SFInt()
def __init__(self):
self.super(TimeDeltaIncrement).__init__()
self.Delta.value = 1
self.Value.value = 0
def on_active(self):
self.Value.value += self.Delta.value
class StatusToggleTrigger(avango.utils.EdgeTrigger):
StatsNumOut = avango.SFInt()
MaxStatsNum = avango.SFInt()
def __init__(self):
self.super(StatusToggleTrigger).__init__()
self.StatsNumOut.value = 0
self.MaxStatsNum.value = 3
def on_up_transition(self):
self.StatsNumOut.value = (self.StatsNumOut.value+1)%self.MaxStatsNum.value
class AddSubtractDeltaTrigger(avango.utils.EdgeTrigger):
Delta = avango.SFInt()
Value = avango.SFInt()
def __init__(self):
self.super(AddSubtractDeltaTrigger).__init__()
self.Delta.value = 1
self.Value.value = 0
def on_down_transition(self):
self.Value.value += self.Delta.value
def on_up_transition(self):
self.Value.value -= self.Delta.value
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 HasFieldCallbacks(avango.script.Script):
value1 = avango.SFInt()
value2 = avango.SFInt()
def __init__(self):
self.super(HasFieldCallbacks).__init__()
self.set_value1 = 0
self.set_value2 = 0
@avango.script.field_has_changed(value1)
def callback1(self):
self.set_value1 = 2
@avango.script.field_has_changed(value2)
def callback2(self):
self.set_value2 = 3
class Picker(avango.script.Script):
SceneGraph = avango.gua.SFSceneGraph()
Ray = avango.gua.SFRayNode()
Options = avango.SFInt()
BlackList = []
WhiteList = []
Results = avango.gua.MFPickResult()
def __init__(self):
self.super(Picker).__init__()
self.always_evaluate(True)
self.SceneGraph.value = avango.gua.nodes.SceneGraph()
self.Ray.value = avango.gua.nodes.RayNode()
self.Options.value = avango.gua.PickingOptions.GET_TEXTURE_COORDS \
| avango.gua.PickingOptions.GET_WORLD_NORMALS \
| avango.gua.PickingOptions.INTERPOLATE_NORMALS \
| avango.gua.PickingOptions.PICK_ONLY_FIRST_FACE
def evaluate(self):
results = self.SceneGraph.value.ray_test(self.Ray.value,
self.Options.value,
self.BlackList,
self.WhiteList)
self.Results.value = results.value
class AInputNode(connect.InputNode):
anint = avango.SFInt()
astring = avango.SFString()
morestrings = avango.MFString()
def __init__(self):
self.super(AInputNode).__init__()
self.anint.value = 0
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 StatsViewer(avango.script.Script):
Views = avango.osg.viewer.MFView()
StatsNum = avango.SFInt()
def __init__(self):
self.super(StatsViewer).__init__()
def evaluate(self):
for view in self.Views.value:
view.StatsMode.value = self.StatsNum.value
class HasSingleFieldCallbackBase2(avango.script.Script):
value2 = avango.SFInt()
def __init__(self):
self.super(HasSingleFieldCallbackBase2).__init__()
self.set_value2 = 0
@avango.script.field_has_changed(value2)
def callback2(self):
self.set_value2 = 2
class DerivedFromMultipleScript(HasSingleFieldCallbackBase1,
HasSingleFieldCallbackBase2):
value3 = avango.SFInt()
def __init__(self):
self.super(DerivedFromMultipleScript).__init__()
self.set_value3 = 0
@avango.script.field_has_changed(value3)
def callback(self):
self.set_value3 = 3
class GenericFieldHasChanged(avango.script.Script):
field = avango.SFInt()
def __init__(self):
self.super(GenericFieldHasChanged).__init__()
self.name = ''
self.value = 0
@avango.script.field_has_changed
def callback(self, name, field):
self.name = name
self.value = field.value
class SplitScreen(avango.script.Script):
Location = avango.gua.SFVec2()
Pipe = avango.gua.SFPipeline()
POISize = avango.SFFloat()
ID = avango.SFInt()
def __init__(self):
self.super(SplitScreen).__init__()
self.__proxy = None
self.__poi = None
def init(self, pipe_id, split_id, graph, screen_size):
self.__screen_size = screen_size
self.__proxy_sphere_size = screen_size.length() * 2
self.POISize.value = 0.2
loader = avango.gua.nodes.TriMeshLoader()
# create proxy sphere ----------------------------------------------------
self.__proxy = loader.create_geometry_from_file(
"proxy" + str(split_id), "data/objects/sphere.obj",
"data/materials/Splitscreen" + str(pipe_id) + ".gmd",
avango.gua.LoaderFlags.DEFAULTS)
graph.Root.value.Children.value.append(self.__proxy)
avango.gua.set_material_uniform(
"data/materials/Splitscreen" + str(pipe_id) + ".gmd", "in_texture",
"splitscreen_pipe" + str(pipe_id))
# create POI marker ------------------------------------------------------
self.__poi = loader.create_geometry_from_file(
"poi" + str(split_id), "data/objects/poi.obj",
"data/materials/White.gmd", avango.gua.LoaderFlags.LOAD_MATERIALS)
graph["/screen"].Children.value.append(self.__poi)
self.update_position()
@field_has_changed(Location)
def update_position(self):
if self.__proxy != None and self.__poi != None:
self.__proxy.Transform.value = avango.gua.make_trans_mat(self.Location.value.x * self.__screen_size.x, 0, self.Location.value.y * self.__screen_size.y) * \
avango.gua.make_scale_mat(self.__proxy_sphere_size/2)
self.__poi.Transform.value = avango.gua.make_trans_mat(self.Location.value.x * self.__screen_size.x, -self.Location.value.y * self.__screen_size.y, self.__proxy_sphere_size*0.51) * \
avango.gua.make_rot_mat(90, 1, 0, 0) * \
avango.gua.make_scale_mat(self.POISize.value)
def get_screen_size(self):
return self.__screen_size
class LShapeView(avango.script.Script):
RootCamera1 = avango.osg.SFNode()
RootCamera2 = avango.osg.SFNode()
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(LShapeView).__init__()
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
self.RootCamera1.value = avango.osg.nodes.Group()
self.RootCamera2.value = avango.osg.nodes.Group()
n = avango.osg.nodes.Group()
self.RootCamera1.value.Children.value.append(n)
n = avango.osg.nodes.Group()
self.RootCamera2.value.Children.value.append(n)
@field_has_changed(Root)
def root_has_changed(self):
self.RootCamera1.value.Children.value[0].Children.value = [
self.Root.value
]
self.RootCamera2.value.Children.value[0].Children.value = [
self.Root.value
]
class PortalPicker(avango.script.Script):
SceneGraph = avango.gua.SFSceneGraph()
Ray = avango.gua.SFRayNode()
Options = avango.SFInt()
Mask = avango.SFString()
Results = avango.gua.MFPickResult()
def __init__(self):
self.super(PortalPicker).__init__()
self.always_evaluate(True)
self.SceneGraph.value = avango.gua.nodes.SceneGraph()
self.Ray.value = avango.gua.nodes.RayNode()
self.Options.value = avango.gua.PickingOptions.PICK_ONLY_FIRST_OBJECT \
| avango.gua.PickingOptions.PICK_ONLY_FIRST_FACE
self.Mask.value = ""
def evaluate(self):
results = self.SceneGraph.value.ray_test(self.Ray.value,
self.Options.value,
self.Mask.value)
self.Results.value = results.value
class View(avango.script.Script):
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(View).__init__()
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
def evaluate(self):
pass
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 FloatXBase(avango.script.Script):
"Base for sequential operations on floats"
BaseFieldName = avango.SFString()
NumFieldsOut = avango.SFInt()
Output = avango.SFFloat()
def __init__(self):
self.super(FloatXBase).__init__()
self.Name.value = "FloatXBase"
self.Output.value = 0
self.BaseFieldName.value = "Input"
self.NumFieldsOut.value = 0
self._actual_id = 0
def add_and_connect_float_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.SFFloat(), field_name, 0)
#connect the field with the given field
getattr(self, field_name).connect_from(field)
self._actual_id += 1
self.NumFieldsOut.value = self._actual_id
def evaluate(self):
self.on_calculate()
def on_calculate(self):
pass
class IndirectField(avango.script.Script):
field = avango.SFInt()
def get(self):
return self.field.value
def add_dynamic_int_fields(self, prefix, num):
for i in range(0, num):
name = str(prefix) + str(i)
self.add_and_init_field(avango.SFInt(), name, 0)
def testAddField(self):
node = Empty()
node.add_field(avango.SFInt(), "field")
self.assert_(node._get_field('field'))
class HasFields(avango.script.Script):
field = avango.SFInt()
anobject = avango.script.SFObject()
class IncValue(avango.script.Script):
field = avango.SFInt()
def evaluate(self):
self.field.value += 1
class TUIOHand(avango.script.Script):
HandClass = avango.SFFloat()
Finger1SID = avango.SFFloat()
Finger2SID = avango.SFFloat()
Finger3SID = avango.SFFloat()
Finger4SID = avango.SFFloat()
Finger5SID = avango.SFFloat()
FingerSIDs = avango.MFFloat()
SessionID = avango.SFFloat()
HandID = avango.SFInt()
CLASS_UNKNOWN = 0
CLASS_LEFT = 1
CLASS_RIGHT = 2
def __init__(self):
self.super(TUIOHand).__init__()
self.FingerSIDs.value = [-1.0, -1.0, -1.0, -1.0, 1.0]
self.SessionID.value = -1.0
self.Finger1SID.value = -1.0
self.Finger2SID.value = -1.0
self.Finger3SID.value = -1.0
self.Finger4SID.value = -1.0
self.Finger5SID.value = -1.0
self.device_sensor = avango.daemon.nodes.DeviceSensor(
DeviceService=avango.daemon.DeviceService())
self.HandClass.connect_from(self.device_sensor.Value0)
self.Finger1SID.connect_from(self.device_sensor.Value1)
self.Finger2SID.connect_from(self.device_sensor.Value2)
self.Finger3SID.connect_from(self.device_sensor.Value3)
self.Finger4SID.connect_from(self.device_sensor.Value4)
self.Finger5SID.connect_from(self.device_sensor.Value5)
self.SessionID.connect_from(self.device_sensor.Value6)
@field_has_changed(HandID)
def set_station(self):
"""
Set station name.
"""
self.device_sensor.Station.value = "gua-finger{}#hand".format(
self.HandID.value)
@field_has_changed(Finger1SID)
def updateFinger1InField(self):
self.FingerSIDs.value[0] = self.Finger1SID.value
@field_has_changed(Finger2SID)
def updateFinger2InField(self):
self.FingerSIDs.value[1] = self.Finger2SID.value
@field_has_changed(Finger3SID)
def updateFinger3InField(self):
self.FingerSIDs.value[2] = self.Finger3SID.value
@field_has_changed(Finger4SID)
def updateFinger4InField(self):
self.FingerSIDs.value[3] = self.Finger4SID.value
@field_has_changed(Finger5SID)
def updateFinger5InField(self):
self.FingerSIDs.value[4] = self.Finger5SID.value
class IncValueWithValues(avango.script.Script):
field = avango.SFInt()
def evaluate(self):
values = self.get_values()
values.field += 1
def testWriteSFInt(self):
sfint = avango.SFInt()
sfint.value = 42
hout = StringIO.StringIO()
connect.write("A", sfint, hout)
self.assertEqual("A\x00SFInt\x0042\n", hout.getvalue())
class BoolXBase(avango.script.Script):
"Base for sequential operations on bools"
BaseFieldName = avango.SFString()
NumFieldsIn = avango.SFInt()
Output = avango.SFBool()
def __init__(self):
self.super(BoolXBase).__init__()
self.Output.value = False
self.BaseFieldName.value = "Input"
self.NumFieldsIn.value = 0
self._actual_id = 0
self.Name.value = "BoolXBase"
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
def remove_and_disconnect_all_fields(self):
for field_id in range(0, self._actual_id):
field_name = self.BaseFieldName.value + str(field_id)
field = self.get_field(field_name)
if not field:
continue
field.disconnect()
self.remove_field(field_name)
self._actual_id = 0
def remove_and_disconnect_field(self, field_number):
if self._actual_id >= field_number:
field_name = self.BaseFieldName.value + str(field_number)
field = self.get_field(field_name)
if not field:
return
field.disconnect()
self.remove_field(field_name)
def evaluate(self):
self.on_calculate()
def on_calculate(self):
pass
def cleanup(self):
self.remove_and_disconnect_all_fields()
