def addLineOfCubes(client, objName: str, numCubes: int): """ Spawn a single body with ``numCubes`` fragments. The body will also be tagged with `objName`. """ # Get the mesh and collision shape for a single cube. vert, csmetabox = demolib.cubeGeometry(0.5, 0.5, 0.5) # Create a fragment template (convenience only for the loop below). ref_frag = demolib.getFragMetaRaw(vert=vert, uv=[], rgb=[]) # Create the fragments and line them up in a line along the x-axis. frags = {} centre = (numCubes - 1) / 2 for idx in range(numCubes): frag_name = str(idx) frag_pos = [(idx - centre) * 2, 0, 0] frags[frag_name] = ref_frag._replace(position=frag_pos) # Rigid body description (defines its physics, not its appearance). body = demolib.getRigidBody(cshapes={'cs': csmetabox}) # Define the object template (physics and appearance) and upload to Azrael. template = Template('PlotObject', body, frags, {}, {}) ret = client.addTemplates([template]) # Spawn one instance. templates = [{'templateID': 'PlotObject', 'rbs': {'position': [0, 0, 0]}}] ret = client.spawn(templates) assert ret.ok objID = ret.data[0] # Tag the object. assert client.setObjectTags({objID: objName})
def _buildTemplate(name, imass, hlen, lf, rf): """ Return a complete template for a cube object. This is a helper function only. """ # Geometry and collision shape for platform. vert, cshapes = demolib.cubeGeometry(hlen, hlen, hlen) # Rigid body data for platforms (defines their physics, not appearance). body = demolib.getRigidBody( cshapes={'cs': cshapes}, linFactor=lf, rotFactor=rf, imass=imass, ) # Geometry for the platforms (defines their appearance, not physics). fm = demolib.getFragMetaRaw( vert=vert, uv=[], rgb=[], scale=1, pos=(0, 0, 0), rot=(0, 0, 0, 1) ) frags = {'frag_1': fm} # Define the platform template and upload it to Azrael. return Template(name, body, frags, {}, {})
def _buildTemplate(name, imass, hlen, lf, rf): """ Return a complete template for a cube object. This is a helper function only. """ # Geometry and collision shape for platform. vert, cshapes = demolib.cubeGeometry(hlen, hlen, hlen) # Rigid body data for platforms (defines their physics, not appearance). body = demolib.getRigidBody( cshapes={'cs': cshapes}, linFactor=lf, rotFactor=rf, imass=imass, ) # Geometry for the platforms (defines their appearance, not physics). fm = demolib.getFragMetaRaw(vert=vert, uv=[], rgb=[], scale=1, pos=(0, 0, 0), rot=(0, 0, 0, 1)) frags = {'frag_1': fm} # Define the platform template and upload it to Azrael. return Template(name, body, frags, {}, {})
def getSmallAsteroidTemplate(hlen): """ Return the template for a small asteroid. A small asteroid is merely a cube with half length ``hlen``. """ vert, cshapes = demolib.cubeGeometry(hlen, hlen, hlen) # Define the geometry of the Asteroids. fm = demolib.getFragMetaRaw( vert=vert, uv=[], rgb=[], scale=1, pos=(0, 0, 0), rot=(0, 0, 0, 1) ) frags = {'frag_1': fm} # Define the physics parameters for the Asteroids. body = demolib.getRigidBody( imass=80, inertia=[1, 1, 1], cshapes={'cs': cshapes}, ) return Template('Asteroid_small', body, frags, {}, {})
def addLineOfCubes(client, objName: str, numCubes: int): """ Spawn a single body with ``numCubes`` fragments. The body will also be tagged with `objName`. """ # Get the mesh and collision shape for a single cube. vert, csmetabox = demolib.cubeGeometry(0.5, 0.5, 0.5) # Create a fragment template (convenience only for the loop below). ref_frag = demolib.getFragMetaRaw(vert=vert, uv=[], rgb=[]) # Create the fragments and line them up in a line along the x-axis. frags = {} centre = (numCubes - 1) / 2 for idx in range(numCubes): frag_name = str(idx) frag_pos = [(idx - centre) * 2, 0, 0] frags[frag_name] = ref_frag._replace(position=frag_pos) # Rigid body description (defines its physics, not its appearance). body = demolib.getRigidBody(cshapes={'cs': csmetabox}) # Define the object template (physics and appearance) and upload to Azrael. template = Template('PlotObject', body, frags, {}, {}) ret = client.addTemplates([template]) # Spawn one instance. templates = [{'templateID': 'PlotObject', 'rbs': {'position': [0, 0, 0]}}] ret = client.spawn(templates) assert ret.ok objID = ret.data[0] # Tag the object. assert client.setObjectTags({objID: objName})
def getLargeAsteroidTemplate(hlen): """ Return the template for a large asteroid. A large asteroids consists of multiple 6 patched together cubes. Each cube has a half length of ``hlen``. """ def _randomise(scale, pos): pos = scale * np.random.uniform(-1, 1, 3) + pos return pos.tolist() # Geometry and collision shape for a single cube. vert, csmetabox = demolib.cubeGeometry(hlen, hlen, hlen) # Define the positions of the individual cubes/fragments in that will # constitute the Asteroid. The positions are slightly randomised to make the # Asteroids somewhat irregular. ofs = 1.5 * hlen noise = 0.6 frag_src = { 'up': _randomise(noise, [0, ofs, 0]), 'down': _randomise(noise, [0, -ofs, 0]), 'left': _randomise(noise, [ofs, 0, 0]), 'right': _randomise(noise, [-ofs, 0, 0]), 'front': _randomise(noise, [0, 0, ofs]), 'back': _randomise(noise, [0, 0, -ofs]), } del ofs # Patch together the fragments that will constitute the geometry of a # single large Asteroid. While at it, also create the individual collision # shapes for each fragment (not part of the geometry but needed # afterwards). frags, cshapes = {}, {} for name, pos in frag_src.items(): frags[name] = demolib.getFragMetaRaw( vert=vert, uv=[], rgb=[], scale=1, pos=pos, rot=[0, 0, 0, 1], ) # Collision shape for this fragment. cshapes[name] = csmetabox._replace(position=pos) del name, pos del frag_src # Specify the physics of the overall bodies. body = demolib.getRigidBody( imass=0.01, inertia=[3, 3, 3], cshapes=cshapes, ) # Return the completed Template. return Template('Asteroid_large', body, frags, {}, {})
def addMolecule(): # Connect to Azrael. client = azrael.clerk.Clerk() # The molecule will consist of several cubes. vert, csmetabox = demolib.cubeGeometry(0.5, 0.5, 0.5) # The molecule object. ofs = 2 frag_src = { 'up': [0, ofs, 0], 'down': [0, -ofs, 0], 'left': [ofs, 0, 0], 'right': [-ofs, 0, 0], 'front': [0, 0, ofs], 'back': [0, 0, -ofs], 'center': [0, 0, 0], } del ofs # frag_src = {'down': frag_src['down']} # frag_src = {'center': frag_src['center']} frags, cshapes = {}, {} for name, pos in frag_src.items(): frags[name] = demolib.getFragMetaRaw( vert=vert, uv=[], rgb=[], scale=1, pos=pos, rot=[0, 0, 0, 1], ) cshapes[name] = csmetabox._replace(position=pos) del name, pos del frag_src # Rigid body data parameters (defines its physics, not appearance). Specify # the centre of mass (com) and principal axis rotation (paxis) for the # inertia values. body = demolib.getRigidBody( imass=0.1, com=[0, -1, 0], inertia=[1, 2, 3], paxis=[0, 0, 0, 1], cshapes=cshapes, ) # Define the object template and upload it to Azrael. template = Template('molecule', body, frags, {}, {}) ret = client.addTemplates([template]) # Spawn one molecule. templates = [{'templateID': 'molecule', 'rbs': {'position': [0, 0.5, 0]}}] objID = client.spawn(templates)
def addMolecule(): # Connect to Azrael. client = azrael.clerk.Clerk() # The molecule will consist of several cubes. vert, csmetabox = demolib.cubeGeometry(0.5, 0.5, 0.5) # The molecule object. ofs = 2 frag_src = { 'up': [0, ofs, 0], 'down': [0, -ofs, 0], 'left': [ofs, 0, 0], 'right': [-ofs, 0, 0], 'front': [0, 0, ofs], 'back': [0, 0, -ofs], 'center': [0, 0, 0], } del ofs # frag_src = {'down': frag_src['down']} # frag_src = {'center': frag_src['center']} frags, cshapes = {}, {} for name, pos in frag_src.items(): frags[name] = demolib.getFragMetaRaw( vert=vert, uv=[], rgb=[], scale=1, pos=pos, rot=[0, 0, 0, 1], ) cshapes[name] = csmetabox._replace(position=pos) del name, pos del frag_src # Rigid body data parameters (defines its physics, not appearance). Specify # the centre of mass (com) and principal axis rotation (paxis) for the # inertia values. body = demolib.getRigidBody( imass=0.1, com=[0, -1, 0], inertia=[1, 2, 3], paxis=[0, 0, 0, 1], cshapes=cshapes, ) # Define the object template and upload it to Azrael. template = Template('molecule', body, frags, {}, {}) ret = client.addTemplates([template]) # Spawn one molecule. templates = [{'templateID': 'molecule', 'rbs': {'position': [0, 0.5, 0]}}] objID = client.spawn(templates)
def addPlatforms(): # Connect to Azrael. client = azrael.clerk.Clerk() # Geometry and collision shape for platform. vert, cshapes = demolib.cubeGeometry(2, 0.1, 2) # Rigid body data for platforms (defines their physics, not appearance). body = demolib.getRigidBody( cshapes={'cs': cshapes}, linFactor=[0, 0, 0], rotFactor=[0, 0, 0] ) # Geometry for the platforms (defines their appearance, not physics). fm = demolib.getFragMetaRaw( vert=vert, uv=[], rgb=[], scale=1, pos=(0, 0, 0), rot=(0, 0, 0, 1) ) frags = {'frag_1': fm} # Define the platform template and upload it to Azrael. template = Template('platform', body, frags, {}, {}) ret = client.addTemplates([template]) # Spawn several platforms at different positions. Their positions are # supposed to create the impression of a stairway. The values assume the # camera is at [0, 0, 10] and points in -z direction. platforms = [] for ii in range(5): pos = (-10 + ii * 5, -ii * 2, -20) platforms.append( { 'templateID': 'platform', 'rbs': { 'position': pos, 'velocityLin': (0, 0, 0), 'scale': 1, 'imass': 20 } } ) platformIDs = client.spawn(platforms) # Tag all platforms with a custom string. cmd = {platformID: 'Platform' for platformID in platformIDs.data} assert client.setObjectTags(cmd)
def addPlatforms(): # Connect to Azrael. client = azrael.clerk.Clerk() # Geometry and collision shape for platform. vert, cshapes = demolib.cubeGeometry(2, 0.1, 2) # Rigid body data for platforms (defines their physics, not appearance). body = demolib.getRigidBody(cshapes={'cs': cshapes}, linFactor=[0, 0, 0], rotFactor=[0, 0, 0]) # Geometry for the platforms (defines their appearance, not physics). fm = demolib.getFragMetaRaw(vert=vert, uv=[], rgb=[], scale=1, pos=(0, 0, 0), rot=(0, 0, 0, 1)) frags = {'frag_1': fm} # Define the platform template and upload it to Azrael. template = Template('platform', body, frags, {}, {}) ret = client.addTemplates([template]) # Spawn several platforms at different positions. Their positions are # supposed to create the impression of a stairway. The values assume the # camera is at [0, 0, 10] and points in -z direction. platforms = [] for ii in range(5): pos = (-10 + ii * 5, -ii * 2, -20) platforms.append({ 'templateID': 'platform', 'rbs': { 'position': pos, 'velocityLin': (0, 0, 0), 'scale': 1, 'imass': 20 } }) platformIDs = client.spawn(platforms) # Tag all platforms with a custom string. cmd = {platformID: 'Platform' for platformID in platformIDs.data} assert client.setObjectTags(cmd)
def spawnCubes(numCols, numRows, numLayers, center=(0, 0, 0)): """ Spawn multiple cubes in a regular grid. The number of cubes equals ``numCols`` * ``numRows`` * ``numLayers``. The center of this "prism" is at ``center``. Every cube has two boosters and two factories. The factories can themselves spawn more (purely passive) cubes. """ # Get a Client instance. client = pyazrael.AzraelClient() # Geometry and collision shape for cube. vert, cs = demolib.cubeGeometry() # Assign the UV coordinates. Each vertex needs a coordinate pair. That # means each triangle needs 6 coordinates. And the cube has 12 triangles. uv = np.zeros(12 * 6, np.float64) uv[0:6] = [0, 0, 1, 0, 1, 1] uv[6:12] = [0, 0, 1, 1, 0, 1] uv[12:18] = [1, 0, 0, 1, 0, 0] uv[18:24] = [1, 0, 1, 1, 0, 1] uv[24:30] = [0, 0, 1, 1, 0, 1] uv[30:36] = [0, 0, 1, 0, 1, 1] uv[36:42] = [1, 1, 1, 0, 0, 0] uv[42:48] = [1, 1, 0, 0, 0, 1] uv[48:54] = [0, 1, 1, 0, 1, 1] uv[54:60] = [0, 1, 0, 0, 1, 0] uv[60:66] = [0, 1, 0, 0, 1, 0] uv[66:72] = [1, 1, 0, 1, 1, 0] uv = np.array(uv, np.float64) # Compile the path to the texture file. path_base = os.path.dirname(os.path.abspath(__file__)) path_base = os.path.join(path_base, '..', 'azrael', 'static', 'img') fname = os.path.join(path_base, 'texture_5.jpg') # Load the texture and convert it to flat vector because this is how OpenGL # will want it. img = PIL.Image.open(fname) img = np.array(img) rgb = np.rollaxis(np.flipud(img), 1).flatten() # ---------------------------------------------------------------------- # Define a cube with boosters and factories. # ---------------------------------------------------------------------- # Two boosters, one left, one right. Both point in the same direction. boosters = { '0': aztypes.Booster(position=[+0.05, 0, 0], direction=[0, 0, 1], force=0), '1': aztypes.Booster(position=[-0.05, 0, 0], direction=[0, 0, 1], force=0) } # ---------------------------------------------------------------------- # Define more booster cubes, each with a different texture. # ---------------------------------------------------------------------- tID_cube = {} templates = [] texture_errors = 0 for ii in range(numRows * numCols * numLayers): # File name of texture. fname = os.path.join(path_base, 'texture_{}.jpg'.format(ii + 1)) # Load the texture image. If the image is unavailable do not endow the # cube with a texture. try: img = PIL.Image.open(fname) img = np.array(img) rgb = np.rollaxis(np.flipud(img), 1) curUV = uv except FileNotFoundError: texture_errors += 1 rgb = curUV = np.array([]) # Create the template. tID = ('BoosterCube_{}'.format(ii)) frags = {'frag_1': demolib.getFragMetaRaw(vert, curUV, rgb), 'frag_2': demolib.getFragMetaRaw(vert, curUV, rgb)} body = demolib.getRigidBody(cshapes={'0': cs}) tmp = Template(tID, body, frags, boosters, {}) templates.append(tmp) # Add the templateID to a dictionary because we will need it in the # next step to spawn the templates. tID_cube[ii] = tID del frags, tmp, tID, fname if texture_errors > 0: print('Could not load texture for {} of the {} objects' .format(texture_errors, ii + 1)) # Define all templates. print('Adding {} templates: '.format(ii + 1), end='', flush=True) t0 = time.time() assert client.addTemplates(templates).ok print('{:.1f}s'.format(time.time() - t0)) # ---------------------------------------------------------------------- # Spawn the differently textured cubes in a regular grid. # ---------------------------------------------------------------------- allObjs = [] cube_idx = 0 cube_spacing = 0.0 # Determine the template and position for every cube. The cubes are *not* # spawned in this loop, but afterwards. print('Compiling scene: ', end='', flush=True) t0 = time.time() for row in range(numRows): for col in range(numCols): for lay in range(numLayers): # Base position of cube. pos = np.array([col, row, lay], np.float64) # Add space in between cubes. pos *= -(4 + cube_spacing) # Correct the cube's position to ensure the center of the # grid coincides with the origin. pos[0] += (numCols // 2) * (1 + cube_spacing) pos[1] += (numRows // 2) * (1 + cube_spacing) pos[2] += (numLayers // 2) * (1 + cube_spacing) # Move the grid to position ``center``. pos += np.array(center) # Store the position and template for this cube. allObjs.append({'template': tID_cube[cube_idx], 'position': pos}) cube_idx += 1 del pos # Since the first four cubes will be chained together we need at least four # of them! assert len(allObjs) >= 4 allObjs = [] pos_0 = [2, 0, -10] pos_1 = [-2, 0, -10] pos_2 = [-6, 0, -10] pos_3 = [-10, 0, -10] allObjs.append({'templateID': tID_cube[0], 'rbs': {'position': pos_0}}) allObjs.append({'templateID': tID_cube[1], 'rbs': {'position': pos_1}}) allObjs.append({'templateID': tID_cube[2], 'rbs': {'position': pos_2}}) allObjs.append({'templateID': tID_cube[3], 'rbs': {'position': pos_3}}) # The first object cannot move (only rotate). It serves as an anchor for # the connected bodies. allObjs[0]['rbs']['linFactor'] = [0, 0, 0] allObjs[0]['rbs']['rotFactor'] = [1, 1, 1] # Add a small damping factor to all bodies to avoid them moving around # perpetually. for oo in allObjs[1:]: oo['rbs']['linFactor'] = [0.9, 0.9, 0.9] oo['rbs']['rotFactor'] = [0.9, 0.9, 0.9] print('{:,} objects ({:.1f}s)'.format(len(allObjs), time.time() - t0)) del cube_idx, cube_spacing, row, col, lay # Spawn the cubes from the templates at the just determined positions. print('Spawning {} objects: '.format(len(allObjs)), end='', flush=True) t0 = time.time() ret = client.spawn(allObjs) assert ret.ok objIDs = ret.data print('{:.1f}s'.format(time.time() - t0)) # Define the constraints. p2p_0 = ConstraintP2P(pivot_a=[-2, 0, 0], pivot_b=[2, 0, 0]) p2p_1 = ConstraintP2P(pivot_a=[-2, 0, 0], pivot_b=[2, 0, 0]) p2p_2 = ConstraintP2P(pivot_a=[-2, 0, 0], pivot_b=[2, 0, 0]) dof = Constraint6DofSpring2( frameInA=[0, 0, 0, 0, 0, 0, 1], frameInB=[0, 0, 0, 0, 0, 0, 1], stiffness=[2, 2, 2, 1, 1, 1], damping=[1, 1, 1, 1, 1, 1], equilibrium=[-2, -2, -2, 0, 0, 0], linLimitLo=[-4.5, -4.5, -4.5], linLimitHi=[4.5, 4.5, 4.5], rotLimitLo=[-0.1, -0.2, -0.3], rotLimitHi=[0.1, 0.2, 0.3], bounce=[1, 1.5, 2], enableSpring=[True, False, False, False, False, False]) constraints = [ ConstraintMeta('', 'p2p', objIDs[0], objIDs[1], p2p_0), ConstraintMeta('', 'p2p', objIDs[1], objIDs[2], p2p_1), ConstraintMeta('', '6DOFSPRING2', objIDs[2], objIDs[3], dof), ] assert client.addConstraints(constraints) == ( True, None, [True] * len(constraints))
def addTexturedCubeTemplates(numCols, numRows, numLayers): # Get a Client instance. client = pyazrael.AzraelClient() # Geometry and collision shape for cube. vert, cs = demolib.cubeGeometry() # Assign the UV coordinates. Each vertex needs a coordinate pair. That # means each triangle needs 6 coordinates. And the cube has 12 triangles. uv = np.zeros(12 * 6, np.float64) uv[0:6] = [0, 0, 1, 0, 1, 1] uv[6:12] = [0, 0, 1, 1, 0, 1] uv[12:18] = [1, 0, 0, 1, 0, 0] uv[18:24] = [1, 0, 1, 1, 0, 1] uv[24:30] = [0, 0, 1, 1, 0, 1] uv[30:36] = [0, 0, 1, 0, 1, 1] uv[36:42] = [1, 1, 1, 0, 0, 0] uv[42:48] = [1, 1, 0, 0, 0, 1] uv[48:54] = [0, 1, 1, 0, 1, 1] uv[54:60] = [0, 1, 0, 0, 1, 0] uv[60:66] = [0, 1, 0, 0, 1, 0] uv[66:72] = [1, 1, 0, 1, 1, 0] uv = np.array(uv, np.float64) # Compile the path to the texture file. path_base = os.path.dirname(os.path.abspath(__file__)) path_base = os.path.join(path_base, '..', 'azrael', 'static', 'img') fname = os.path.join(path_base, 'texture_5.jpg') # Load the texture and convert it to a flat vector because this is how # OpenGL will want it. img = PIL.Image.open(fname) img = np.array(img) rgb = np.rollaxis(np.flipud(img), 1) # ---------------------------------------------------------------------- # Create templates for the factory output. # ---------------------------------------------------------------------- tID_1 = 'Product1' tID_2 = 'Product2' frags_1 = {'frag_1': demolib.getFragMetaRaw(0.75 * vert, uv, rgb)} frags_2 = {'frag_1': demolib.getFragMetaRaw(0.24 * vert, uv, rgb)} body = demolib.getRigidBody(cshapes={'0': cs}) t1 = Template(tID_1, body, frags_1, {}, {}) t2 = Template(tID_2, body, frags_2, {}, {}) assert client.addTemplates([t1, t2]).ok del frags_1, frags_2, t1, t2 # ---------------------------------------------------------------------- # Define a cube with boosters and factories. # ---------------------------------------------------------------------- # Two boosters, one left, one right. Both point in the same direction. boosters = { '0': aztypes.Booster(position=[+0.05, 0, 0], direction=[0, 0, 1], force=0), '1': aztypes.Booster(position=[-0.05, 0, 0], direction=[0, 0, 1], force=0) } # Two factories, one left one right. They will eject the new objects # forwards and backwards, respectively. factories = { '0': aztypes.Factory(position=[+1.5, 0, 0], direction=[+1, 0, 0], templateID=tID_1, exit_speed=[0.1, 1]), '1': aztypes.Factory(position=[-1.5, 0, 0], direction=[-1, 0, 0], templateID=tID_2, exit_speed=[0.1, 1]) } # Add the template. tID_3 = 'BoosterCube' frags = {'frag_1': demolib.getFragMetaRaw(vert, uv, rgb)} body = demolib.getRigidBody(cshapes={'0': cs}) t3 = Template(tID_3, body, frags, boosters, factories) assert client.addTemplates([t3]).ok del frags, t3 # ---------------------------------------------------------------------- # Define more booster cubes, each with a different texture. # ---------------------------------------------------------------------- tID_cube = {} templates = [] texture_errors = 0 for ii in range(numRows * numCols * numLayers): # File name of texture. fname = os.path.join(path_base, 'texture_{}.jpg'.format(ii + 1)) # Load the texture image. If the image is unavailable do not endow the # cube with a texture. try: img = PIL.Image.open(fname) img = np.array(img) rgb = np.rollaxis(np.flipud(img), 1) curUV = uv except FileNotFoundError: texture_errors += 1 rgb = curUV = np.array([]) # Create the template. tID = ('BoosterCube_{}'.format(ii)) frags = {'frag_1': demolib.getFragMetaRaw(vert, curUV, rgb), 'frag_2': demolib.getFragMetaRaw(vert, curUV, rgb)} body = demolib.getRigidBody(cshapes={'0': cs}) tmp = Template(tID, body, frags, boosters, {}) templates.append(tmp) # Add the templateID to a dictionary because we will need it in the # next step to spawn the templates. tID_cube[ii] = tID del frags, tmp, tID, fname if texture_errors > 0: print('Could not load texture for {} of the {} objects' .format(texture_errors, ii + 1)) # Define all templates. print('Adding {} templates: '.format(ii + 1), end='', flush=True) t0 = time.time() assert client.addTemplates(templates).ok print('{:.1f}s'.format(time.time() - t0)) return tID_cube
def spawnCubes(numCols, numRows, numLayers, center=(0, 0, 0)): """ Spawn multiple cubes in a regular grid. The number of cubes equals ``numCols`` * ``numRows`` * ``numLayers``. The center of this "prism" is at ``center``. Every cube has two boosters and two factories. The factories can themselves spawn more (purely passive) cubes. """ # Get a Client instance. client = pyazrael.AzraelClient() # Geometry and collision shape for cube. vert, cs = demolib.cubeGeometry() # Assign the UV coordinates. Each vertex needs a coordinate pair. That # means each triangle needs 6 coordinates. And the cube has 12 triangles. uv = np.zeros(12 * 6, np.float64) uv[0:6] = [0, 0, 1, 0, 1, 1] uv[6:12] = [0, 0, 1, 1, 0, 1] uv[12:18] = [1, 0, 0, 1, 0, 0] uv[18:24] = [1, 0, 1, 1, 0, 1] uv[24:30] = [0, 0, 1, 1, 0, 1] uv[30:36] = [0, 0, 1, 0, 1, 1] uv[36:42] = [1, 1, 1, 0, 0, 0] uv[42:48] = [1, 1, 0, 0, 0, 1] uv[48:54] = [0, 1, 1, 0, 1, 1] uv[54:60] = [0, 1, 0, 0, 1, 0] uv[60:66] = [0, 1, 0, 0, 1, 0] uv[66:72] = [1, 1, 0, 1, 1, 0] uv = np.array(uv, np.float64) # Compile the path to the texture file. path_base = os.path.dirname(os.path.abspath(__file__)) path_base = os.path.join(path_base, '..', 'azrael', 'static', 'img') fname = os.path.join(path_base, 'texture_5.jpg') # Load the texture and convert it to flat vector because this is how OpenGL # will want it. img = PIL.Image.open(fname) img = np.array(img) rgb = np.rollaxis(np.flipud(img), 1).flatten() # ---------------------------------------------------------------------- # Define a cube with boosters and factories. # ---------------------------------------------------------------------- # Two boosters, one left, one right. Both point in the same direction. boosters = { '0': aztypes.Booster(position=[+0.05, 0, 0], direction=[0, 0, 1], force=0), '1': aztypes.Booster(position=[-0.05, 0, 0], direction=[0, 0, 1], force=0) } # ---------------------------------------------------------------------- # Define more booster cubes, each with a different texture. # ---------------------------------------------------------------------- tID_cube = {} templates = [] texture_errors = 0 for ii in range(numRows * numCols * numLayers): # File name of texture. fname = os.path.join(path_base, 'texture_{}.jpg'.format(ii + 1)) # Load the texture image. If the image is unavailable do not endow the # cube with a texture. try: img = PIL.Image.open(fname) img = np.array(img) rgb = np.rollaxis(np.flipud(img), 1) curUV = uv except FileNotFoundError: texture_errors += 1 rgb = curUV = np.array([]) # Create the template. tID = ('BoosterCube_{}'.format(ii)) frags = { 'frag_1': demolib.getFragMetaRaw(vert, curUV, rgb), 'frag_2': demolib.getFragMetaRaw(vert, curUV, rgb) } body = demolib.getRigidBody(cshapes={'0': cs}) tmp = Template(tID, body, frags, boosters, {}) templates.append(tmp) # Add the templateID to a dictionary because we will need it in the # next step to spawn the templates. tID_cube[ii] = tID del frags, tmp, tID, fname if texture_errors > 0: print('Could not load texture for {} of the {} objects'.format( texture_errors, ii + 1)) # Define all templates. print('Adding {} templates: '.format(ii + 1), end='', flush=True) t0 = time.time() assert client.addTemplates(templates).ok print('{:.1f}s'.format(time.time() - t0)) # ---------------------------------------------------------------------- # Spawn the differently textured cubes in a regular grid. # ---------------------------------------------------------------------- allObjs = [] cube_idx = 0 cube_spacing = 0.0 # Determine the template and position for every cube. The cubes are *not* # spawned in this loop, but afterwards. print('Compiling scene: ', end='', flush=True) t0 = time.time() for row in range(numRows): for col in range(numCols): for lay in range(numLayers): # Base position of cube. pos = np.array([col, row, lay], np.float64) # Add space in between cubes. pos *= -(4 + cube_spacing) # Correct the cube's position to ensure the center of the # grid coincides with the origin. pos[0] += (numCols // 2) * (1 + cube_spacing) pos[1] += (numRows // 2) * (1 + cube_spacing) pos[2] += (numLayers // 2) * (1 + cube_spacing) # Move the grid to position ``center``. pos += np.array(center) # Store the position and template for this cube. allObjs.append({ 'template': tID_cube[cube_idx], 'position': pos }) cube_idx += 1 del pos # Since the first four cubes will be chained together we need at least four # of them! assert len(allObjs) >= 4 allObjs = [] pos_0 = [2, 0, -10] pos_1 = [-2, 0, -10] pos_2 = [-6, 0, -10] pos_3 = [-10, 0, -10] allObjs.append({'templateID': tID_cube[0], 'rbs': {'position': pos_0}}) allObjs.append({'templateID': tID_cube[1], 'rbs': {'position': pos_1}}) allObjs.append({'templateID': tID_cube[2], 'rbs': {'position': pos_2}}) allObjs.append({'templateID': tID_cube[3], 'rbs': {'position': pos_3}}) # The first object cannot move (only rotate). It serves as an anchor for # the connected bodies. allObjs[0]['rbs']['linFactor'] = [0, 0, 0] allObjs[0]['rbs']['rotFactor'] = [1, 1, 1] # Add a small damping factor to all bodies to avoid them moving around # perpetually. for oo in allObjs[1:]: oo['rbs']['linFactor'] = [0.9, 0.9, 0.9] oo['rbs']['rotFactor'] = [0.9, 0.9, 0.9] print('{:,} objects ({:.1f}s)'.format(len(allObjs), time.time() - t0)) del cube_idx, cube_spacing, row, col, lay # Spawn the cubes from the templates at the just determined positions. print('Spawning {} objects: '.format(len(allObjs)), end='', flush=True) t0 = time.time() ret = client.spawn(allObjs) assert ret.ok objIDs = ret.data print('{:.1f}s'.format(time.time() - t0)) # Define the constraints. p2p_0 = ConstraintP2P(pivot_a=[-2, 0, 0], pivot_b=[2, 0, 0]) p2p_1 = ConstraintP2P(pivot_a=[-2, 0, 0], pivot_b=[2, 0, 0]) p2p_2 = ConstraintP2P(pivot_a=[-2, 0, 0], pivot_b=[2, 0, 0]) dof = Constraint6DofSpring2( frameInA=[0, 0, 0, 0, 0, 0, 1], frameInB=[0, 0, 0, 0, 0, 0, 1], stiffness=[2, 2, 2, 1, 1, 1], damping=[1, 1, 1, 1, 1, 1], equilibrium=[-2, -2, -2, 0, 0, 0], linLimitLo=[-4.5, -4.5, -4.5], linLimitHi=[4.5, 4.5, 4.5], rotLimitLo=[-0.1, -0.2, -0.3], rotLimitHi=[0.1, 0.2, 0.3], bounce=[1, 1.5, 2], enableSpring=[True, False, False, False, False, False]) constraints = [ ConstraintMeta('', 'p2p', objIDs[0], objIDs[1], p2p_0), ConstraintMeta('', 'p2p', objIDs[1], objIDs[2], p2p_1), ConstraintMeta('', '6DOFSPRING2', objIDs[2], objIDs[3], dof), ] assert client.addConstraints(constraints) == (True, None, [True] * len(constraints))