New sketch Starz

Author: tildebyte

Starz_HYPE/Starz_HYPE.pyde

@@ -0,0 +1,49 @@
+# add_library('hype')
+'''
+1. One hundred `HRect`
+2. Of randomly-selected size
+3. Each having semi-tranparent fill and stroke
+4. Each colored according to an underlying `HColorField`
+5. Each rotating around its own center with a randomly-selected speed and
+   direction
+6. Randomly distributed around the circumference of
+7. One of several concentric circles
+8. All squares rotating at a randomly-selected speed and direction around
+   a common center point
+
+Implementation by Ben Alkov 7-12 August 2014
+
+'''
+from hype.core.util import H
+from hype.extended.colorist import HColorField
+from hype.extended.drawable import HGroup
+from hype.extended.drawable import HRect
+
+import util
+
+from parentcallback import ParentCallback
+from tricallback import TriCallback
+
+
+def setup():
+    size(512, 512)
+    util.centerX = width / 2
+    util.centerY = height / 2
+    frameRate(30)
+    H.init(this).background(0)  # #000000
+    smooth()
+    # No `requestAll()` for the visible HRects. They will be requested inside
+    # the parent's callback.
+    util.visiblePool.add(HRect())\
+               .onCreate(TriCallback())
+    util.parentPool.autoAddToStage()\
+              .add(HGroup())\
+              .onCreate(ParentCallback())\
+              .requestAll()
+
+
+def draw():
+    H.drawStage()
+    # saveFrame('C:/Users/IBM_ADMIN/Documents/frames/####.tif')
+    # if frameCount == 900:
+    #     exit()

Starz_HYPE/parentcallback.py

@@ -0,0 +1,29 @@
+'''
+`draw()` loop callback for the invisible parent `HGroup`s.
+'''
+from hype.core.util import H
+from hype.core.interfaces import HCallback
+
+import util
+
+
+class ParentCallback(HCallback):
+    @staticmethod
+    def run(parent):
+        # Pull one HRect from the pool of visible HRects.
+        child = util.visiblePool.request()
+        parent.noStroke()\
+              .noFill()\
+              .size(3)\
+              .rotation(random(360))
+        # In order for the object to rotate *on* the orbit, around the
+        # *orbit's* center, we have to set its center to the center of the
+        # orbit, and then calculate its position on the orbit based on the
+        # child's position.
+        parent.loc(util.centerX, util.centerY)\
+              .anchor(abs(child.x() - util.centerX),
+                      abs(child.y() - util.centerY))
+        parent.add(child)
+        # Move the child to the parent's center.
+        child.locAt(H.CENTER)
+        util.applyRotation(parent, 0.5, 0.01)

Starz_HYPE/tricallback.py

@@ -0,0 +1,20 @@
+'''
+`draw()` loop callback for the visible tris.
+'''
+from hype.core.util import H
+from hype.core.interfaces import HCallback
+
+import util
+
+
+class TriCallback(HCallback):
+    @staticmethod
+    def run(drawable):
+        # Position this HTri around its parent's center, at an angle based on
+        # its index.
+        # fill(random(288, 360), random(100, 255), random(51, 153), random(5, 15))
+        drawable.noStroke()\
+                .fill(0xff000000, 100)\
+                .rotation(TAU / self.index)\
+                .loc(0, 0)\
+                .anchorAt(H.CENTER_BOTTOM)

Starz_HYPE/util.py

@@ -0,0 +1,65 @@
+'''
+Globals and helper methods.
+'''
+from hype.extended.behavior import HRotate
+from hype.extended.util import HDrawablePool
+
+from random import randint
+
+
+colorfield = None
+centerX = None
+centerY = None
+visiblePool = HDrawablePool(100)
+parentPool = HDrawablePool(100)
+
+
+def positionOnOrbit():
+    '''
+    Generate a random position on the circumference of the orbit chosen for
+    this item.
+    '''
+    angle = random(TAU)
+    # `randint` slightly offsets the position so we don't end up with the
+    # visible HRects orbiting on *exact* circles.
+    radius = chooseOrbit() + randint(0, 22)
+    createX = centerX + (cos(angle) * radius)  # `angle` *must* be radians.
+    createY = centerY + (sin(angle) * radius)  #
+    return createX, createY
+
+
+def chooseOrbit():
+    '''
+    Randomly choose an orbit, based on a set of weights.
+    '''
+    chance = random(1)
+    if chance < 0.18:
+        return 64
+    elif chance < 0.50:
+        return 128
+    elif chance < 0.78:
+        return 208
+    elif chance < 1.0:
+        return 288
+
+
+def applyRotation(obj, speed, tolerance):
+    '''
+    Attach an HRotate to the given object, with speed `speed`.
+    '''
+    HRotate(obj, avoidZero(speed, tolerance))
+
+
+# This is specifically used to avoid zero or synchronous rotation. We want all
+# visible HRects to *appear* to rotate in place.
+def avoidZero(limit, tolerance):
+    '''
+    Return a random value in the range from `-limit` to `limit - 1`, excluding
+    the inner range from `-tolerance` to `tolerance - 1` (and, logically, zero
+    as well).
+    '''
+    value = random(-limit, limit)
+    while -tolerance < value < tolerance:
+        value = random(-limit, limit)
+        continue
+    return value