multiple_objects.py

import math
import time
import logging
import os.path
import collections
import random
import itertools as it

logging.basicConfig(level=logging.WARNING)

from freemoovr.proxy.base_zmq import ServerBaseZMQ
from freemoovr.proxy.stimulus_osg import StimulusOSG2Controller

from lutil import PathIter, TimedTrue

########
# a demo which compares the performance of different clone types
# when duplicating a loaded model. in auto/deep clone mode the
# models are faded in and then sequentially started to animate
#
# in shallow clone mode, because the models are linked and not
# independently animateable and fadeable, they are not faded or
# animated individually
########

# if true, expects 'locust diffuse2.jpg' and 'locust_lp_120.osgt' in this directory
TRY_USE_LOCUST = True

# how to clone the model. in normal operation use only 'auto' or 'shallow'. deep is
# mostly used during engine development to validate the auto clone mode does the right
# thing
HOW = 'auto'
assert HOW in ('shallow', 'deep', 'auto')

# sequentially fade in all the models, 1 per second. With a lot of models (see DUPLICATES)
# this can take a long time. Is automatically disabled if using a shallow clone as that creates
# 1000 models
CAN_HIDE = False

p = os.path.abspath('locust_lp_120.osgt')
ANIMATION = 'ArmatureAction'
if (not os.path.exists(p)) or (not TRY_USE_LOCUST):
    p = '1_object_1_animation_osgexp0130.osgt'  # relative paths are in the compilation data directory
    ANIMATION = 'ArmatureAction_O1'

    print "to use a locust model, put 'locust diffuse2.jpg' and 'locust_lp_120.osgt' in this directory"

vr = StimulusOSG2Controller(server_ids=['default-id'])

# how many clones
DUPLICATES = 1000 if HOW == 'shallow' else 100

DT = 1/30.

nodes = {'_original': vr.load_osg(p)}
paths = {'_original': PathIter(0.5, 0.5, DT).walk()}
visible = {}

for i in range(DUPLICATES):
    name = 'copy%d' % i
    nodes[name] = nodes['_original'].clone(name, how=HOW)
    paths[name] = PathIter(1 + (i * 0.5), 1 + (i * 0.01), DT).walk()

vr.wait_for_servers()

if (HOW != 'shallow') and CAN_HIDE:
    print "hiding all"
    for node in nodes.values():
        node.move(hidden=True)
else:
    print "not hiding all"
    visible = {n: True for n in nodes}

vr.wait_for_servers()

# wait for 5s to give you a chance to set the camera
time.sleep(5)

observer_path = PathIter(0, dt=DT).walk()

started = {}

every_1s = TimedTrue(hz=1)

for j in it.count():
    opos = next(observer_path)

    # move them all
    for idx, name in enumerate(sorted(nodes)):
        node = nodes[name]
        path = paths[name]

        pos = next(path)
        if visible.get(name):
            node.move(*pos)

    if every_1s:
        if HOW == 'shallow':
            name = '_original'
        else:
            # randomly start an animation
            name = random.choice(nodes.keys())

        node = nodes[name]

        already_visible = (not CAN_HIDE) or (HOW == 'shallow') or visible.get(name)
        if already_visible:
            if not started.get(name):
                node.animation_start(ANIMATION)
                started[name] = True
                print "start", name
        elif (HOW != 'shallow') and CAN_HIDE:
            if not visible.get(name):
                node.fade_in()
                visible[name] = True
                print "fade_in", name

    vr.set_position(*opos)
    time.sleep(DT)

    if (j % 20) == 0:
        print "fps", vr.get_framerate()