Exemplo n.º 1
0
def initEvents(initFlag=vizconnect.INIT_INDEPENDENT, initList=None):
	#VC: place any general initialization code here
	rawEvent = vizconnect.getRawEventDict()

	#VC: initialize a new event
	_name = 'CHANGE_SCENES'
	if vizconnect.isPendingInit('event', _name, initFlag, initList):
		#VC: init the raw object
		if initFlag&vizconnect.INIT_RAW:
			#VC: create the raw object
			from vizconnect.util import events
			rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))
	
		#VC: init the mappings for the raw object
		if initFlag&vizconnect.INIT_MAPPINGS:
			#VC: per frame mappings
			if initFlag&vizconnect.INIT_MAPPINGS_PER_FRAME:
				#VC: get the raw input dict so we have access to signals
				import vizact
				rawInput = vizconnect.getConfiguration().getRawDict('input')
				#VC: set the update function which checks for input signals
				def update(event):
					if rawInput['keyboard'].isButtonDown(46):# make=Generic, model=Keyboard, name=keyboard, signal=Key C
						event.sendOnce(e=viz.Event(mag=1))
				rawEvent[_name].setUpdateFunction(update)
	
		#VC: init the wrapper (DO NOT EDIT)
		if initFlag&vizconnect.INIT_WRAPPERS:
			vizconnect.addEvent(rawEvent[_name], _name, make='Vizconnect', model='Custom')

	#VC: return values can be modified here
	return None
def initEvents(initFlag=vizconnect.INIT_INDEPENDENT, initList=None):
	#VC: place any general initialization code here
	rawEvent = vizconnect.getRawEventDict()

	#VC: initialize a new event
	_name = 'TOGGLE_MODEL_EVENT'
	if vizconnect.isPendingInit('event', _name, initFlag, initList):
		#VC: init the raw object
		if initFlag&vizconnect.INIT_RAW:
			#VC: create the raw object
			from vizconnect.util import events
			rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))
	
		#VC: init the mappings for the raw object
		if initFlag&vizconnect.INIT_MAPPINGS:
			#VC: per frame mappings
			if initFlag&vizconnect.INIT_MAPPINGS_PER_FRAME:
				#VC: get the raw input dict so we have access to signals
				import vizact
				rawInput = vizconnect.getConfiguration().getRawDict('input')
				#VC: set the update function which checks for input signals
				def update(event):
					if rawInput['keyboard'].isButtonDown(47):# make=Generic, model=Keyboard, name=keyboard, signal=Key V
						event.sendOnce(e=viz.Event(mag=1))
				rawEvent[_name].setUpdateFunction(update)
	
		#VC: init the wrapper (DO NOT EDIT)
		if initFlag&vizconnect.INIT_WRAPPERS:
			vizconnect.addEvent(rawEvent[_name], _name, make='Vizconnect', model='Custom')

	#VC: initialize a new event
	_name = 'RESTORE_MODEL_EVENT'
	if vizconnect.isPendingInit('event', _name, initFlag, initList):
		#VC: init the raw object
		if initFlag&vizconnect.INIT_RAW:
			#VC: create the raw object
			from vizconnect.util import events
			rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))
	
		#VC: init the mappings for the raw object
		if initFlag&vizconnect.INIT_MAPPINGS:
			#VC: per frame mappings
			if initFlag&vizconnect.INIT_MAPPINGS_PER_FRAME:
				#VC: get the raw input dict so we have access to signals
				import vizact
				rawInput = vizconnect.getConfiguration().getRawDict('input')
				#VC: set the update function which checks for input signals
				def update(event):
					if rawInput['keyboard'].isButtonDown(19):# make=Generic, model=Keyboard, name=keyboard, signal=Key R
						event.sendOnce(e=viz.Event(mag=1))
				rawEvent[_name].setUpdateFunction(update)
	
		#VC: init the wrapper (DO NOT EDIT)
		if initFlag&vizconnect.INIT_WRAPPERS:
			vizconnect.addEvent(rawEvent[_name], _name, make='Vizconnect', model='Custom')

	#VC: return values can be modified here
	return None
Exemplo n.º 3
0
def initEvents(initFlag=vizconnect.INIT_INDEPENDENT, initList=None):
	#VC: place any general initialization code here
	rawEvent = vizconnect.getRawEventDict()

	#VC: initialize a new event
	_name = 'buttondown'
	if vizconnect.isPendingInit('event', _name, initFlag, initList):
		#VC: init the raw object
		if initFlag&vizconnect.INIT_RAW:
			#VC: create the raw object
			from vizconnect.util import events
			rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))
	
		#VC: init the wrapper (DO NOT EDIT)
		if initFlag&vizconnect.INIT_WRAPPERS:
			vizconnect.addEvent(rawEvent[_name], _name, make='Vizconnect', model='Custom')

	#VC: return values can be modified here
	return None
def initWrappers():

	# get all of the raw items from vizconnect
	rawGroup = vizconnect.getRawGroupDict()
	rawInput = vizconnect.getRawInputDict()
	rawDisplay = vizconnect.getRawDisplayDict()
	rawTracker = vizconnect.getRawTrackerDict()
	rawTransport = vizconnect.getRawTransportDict()
	rawEvent = vizconnect.getRawEventDict()
	rawTool = vizconnect.getRawToolDict()
	rawAvatar = vizconnect.getRawAvatarDict()
	rawAnimator = vizconnect.getRawAnimatorDict()

	# below are listed the wrapped group objects

	# below are listed the wrapped display objects
	vizconnect.addDisplay(rawDisplay['zsight_60'], 'zsight_60', '', 'Sensics', 'zSight 60')

	# below are listed the wrapped tracker objects
	vizconnect.addTracker(rawTracker['ppt_Rhead'], 'ppt_Rhead', 'ppt', 'WorldViz', 'PPT')
	vizconnect.addTracker(rawTracker['optical_heading'], 'optical_heading', '', 'Virtual', 'Optical Heading')
	vizconnect.addTracker(rawTracker['ppt_hand'], 'ppt_hand', 'ppt', 'WorldViz', 'PPT')
	vizconnect.addTracker(rawTracker['osv3_sensor_bus'], 'osv3_sensor_bus', '', 'Inertial Labs', 'OSv3 (Sensor Bus)')
	vizconnect.addTracker(rawTracker['ppt_Lhead'], 'ppt_Lhead', 'ppt', 'WorldViz', 'PPT')

	# below are listed the wrapped input objects

	# below are listed the wrapped event objects

	# below are listed the wrapped transport objects

	# below are listed the wrapped tool objects

	# below are listed the wrapped avatar objects


	return True
def initEvents(initFlag=vizconnect.INIT_INDEPENDENT, initList=None):
    #VC: place any general initialization code here
    rawEvent = vizconnect.getRawEventDict()

    #VC: return values can be modified here
    return None
def initEvents(initFlag=vizconnect.INIT_INDEPENDENT, initList=None):
	#VC: place any general initialization code here
	rawEvent = vizconnect.getRawEventDict()
	
	#VC: return values can be modified here
	return None
def initEvents(initFlag=vizconnect.INIT_INDEPENDENT, initList=None):
    #VC: place any general initialization code here
    rawEvent = vizconnect.getRawEventDict()

    #VC: initialize a new event
    _name = 'CONTROL_NEW_FILE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            49
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key N
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CLIP'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            48
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key B
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CLOUD_INCREASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            23
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key I
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CLOUD_DECREASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            37
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key K
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_TOGGLE_ENVIRONMENT'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            19
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key R
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CYCLE_VIEW_MODE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            47
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key V
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_LEFT_HAND_GRAB'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['joystick'].isButtonDown(
                            5
                    ):  # make=Generic, model=Joystick, name=joystick, signal=Button 5
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_LEFT_HAND_RELEASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if not rawInput['joystick'].isButtonDown(
                            5
                    ):  # make=Generic, model=Joystick, name=joystick, signal=Button 5
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_RIGHT_HAND_GRAB'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['joystick'].isButtonDown(
                            6
                    ):  # make=Generic, model=Joystick, name=joystick, signal=Button 6
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_RIGHT_HAND_RELEASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if not rawInput['joystick'].isButtonDown(
                            6
                    ):  # make=Generic, model=Joystick, name=joystick, signal=Button 6
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: return values can be modified here
    return None
def initEvents(initFlag=vizconnect.INIT_INDEPENDENT, initList=None):
    #VC: place any general initialization code here
    rawEvent = vizconnect.getRawEventDict()

    #VC: initialize a new event
    _name = 'CONTROL_NEW_FILE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            49
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key N
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CYCLE_VIEW_MODE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['l_hand_input'].isButtonDown(
                            0
                    ):  # make=HTC, model=Vive Controller, name=l_hand_input, signal=Button Menu
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_MATERIAL_TRIGGER'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['r_hand_input'].isButtonDown(
                            3
                    ):  # make=HTC, model=Vive Controller, name=r_hand_input, signal=Button Trackpad
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CLIP'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['r_hand_input'].isButtonDown(
                            1
                    ):  # make=HTC, model=Vive Controller, name=r_hand_input, signal=Button Grip
                        event.sendOnce(e=viz.Event(mag=1))
                    if rawInput['l_hand_input'].isButtonDown(
                            1
                    ):  # make=HTC, model=Vive Controller, name=l_hand_input, signal=Button Grip
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CLOUD_INCREASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['l_hand_input'].getTrackpad()[1] > 0.01 and\
                     rawInput['l_hand_input'].isButtonDown(3):# make=HTC, model=Vive Controller, name=l_hand_input, signal=Trackpad Top (along with) make=HTC, model=Vive Controller, name=l_hand_input, signal=Button Trackpad
                        event.sendOnce(e=viz.Event(mag=abs(
                            rawInput['l_hand_input'].getTrackpad()[1]) * 1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_CLOUD_DECREASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['l_hand_input'].getTrackpad()[1] < -0.01 and\
                     rawInput['l_hand_input'].isButtonDown(3):# make=HTC, model=Vive Controller, name=l_hand_input, signal=Trackpad Bottom (along with) make=HTC, model=Vive Controller, name=l_hand_input, signal=Button Trackpad
                        event.sendOnce(e=viz.Event(mag=abs(
                            rawInput['l_hand_input'].getTrackpad()[1]) * 1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_TOGGLE_STRESSINDICATOR'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['r_hand_input'].isButtonDown(
                            0
                    ):  # make=HTC, model=Vive Controller, name=r_hand_input, signal=Button Menu
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_TOGGLE_ENVIRONMENT'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['keyboard'].isButtonDown(
                            19
                    ):  # make=Generic, model=Keyboard, name=keyboard, signal=Key R
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_LEFT_HAND_GRAB'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['l_hand_input'].isButtonDown(
                            2
                    ):  # make=HTC, model=Vive Controller, name=l_hand_input, signal=Button Trigger
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_LEFT_HAND_RELEASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if not rawInput['l_hand_input'].isButtonDown(
                            2
                    ):  # make=HTC, model=Vive Controller, name=l_hand_input, signal=Button Trigger
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_RIGHT_HAND_GRAB'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['r_hand_input'].isInMode(
                            'super'
                    ) and rawInput['r_hand_input'].isButtonDown(
                            2
                    ):  # make=HTC, model=Vive Controller, name=r_hand_input, signal=Button Trigger
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: initialize a new event
    _name = 'CONTROL_RIGHT_HAND_RELEASE'
    if vizconnect.isPendingInit('event', _name, initFlag, initList):
        #VC: init the raw object
        if initFlag & vizconnect.INIT_RAW:
            #VC: create the raw object
            from vizconnect.util import events
            rawEvent[_name] = events.CustomEvent(viz.getEventID(_name))

        #VC: init the mappings for the raw object
        if initFlag & vizconnect.INIT_MAPPINGS:
            #VC: per frame mappings
            if initFlag & vizconnect.INIT_MAPPINGS_PER_FRAME:
                #VC: get the raw input dict so we have access to signals
                import vizact
                rawInput = vizconnect.getConfiguration().getRawDict('input')

                #VC: set the update function which checks for input signals
                def update(event):
                    if rawInput['r_hand_input'].isInMode(
                            'super'
                    ) and not rawInput['r_hand_input'].isButtonDown(
                            2
                    ):  # make=HTC, model=Vive Controller, name=r_hand_input, signal=Button Trigger
                        event.sendOnce(e=viz.Event(mag=1))

                rawEvent[_name].setUpdateFunction(update)

        #VC: init the wrapper (DO NOT EDIT)
        if initFlag & vizconnect.INIT_WRAPPERS:
            vizconnect.addEvent(rawEvent[_name],
                                _name,
                                make='Vizconnect',
                                model='Custom')

    #VC: return values can be modified here
    return None