Esempio n. 1
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        # Grab the raw audio buffers
        newbuffer = audio_engine.mono_buffer()

        # Make sure they aren't empty!!
        if (len(newbuffer) == 0):
            return
        else:
            self.mono = newbuffer

        # Openlase can only draw 30000 points in one cycle (less that
        # that, actually!).  Clear the audio buffer and try again!
        if self.mono.shape[0] > 10000:
            audio_engine.clear_all()

        ol.loadIdentity3()
        ol.color3(*(self.color_cycle()))

        ol.begin(ol.POINTS)
        for i in range(0, self.mono.shape[0]-1, self.SUBSAMP):

            val = tanh(self.mono[i] * self.BOOST)
            val = val * 0.5 + 0.5
            val = val * (self.MAX_SIZE - self.MIN_SIZE) + self.MIN_SIZE
            
            ol.vertex3((cos(self.pos) * val, sin(self.pos) * val, -1))
            
            self.pos = self.pos + self.W / 30000.0;
            while(self.pos >= 2*pi):
                self.pos = self.pos -2*pi
        ol.end()
Esempio n. 2
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        ol.loadIdentity3()
        ol.perspective(20, 1, 1, 100)
        ol.translate3((0, 0, -20))

        ol.color3(1.0, 1.0, 0.0)
        ol.translate3(
            (cos(lux.time / 2.0), cos(lux.time / 3.0), cos(lux.time / 7.0)))
        ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
        ol.rotate3X(lux.time * pi * 0.25 * lux.simple_rate)
        ol.rotate3Y(lux.time * pi * 0.13 * lux.simple_rate)

        for row in self.torender:
            ol.begin(ol.LINESTRIP)
            vi = self.faces[row]
            vi = vi + [vi[0]]

            for i in vi:
                tup = tuple(self.verts[i, :])
                ol.vertex3(tup)

            ol.end()
Esempio n. 3
0
    def draw(self):

        self.x_phase = 0.4*cos(1.7 * lux.time * self.RATE) + 0.6*cos(0.7 * lux.time * self.RATE)
        self.y_phase = cos(2.2 * lux.time * self.RATE)
        self.z_phase = cos(5.7 * lux.time * self.RATE)
        self.z_ratio = 2 + cos(0.1 * lux.time * self.RATE)

        ol.loadIdentity3()
        ol.loadIdentity()

        ol.perspective(20, 1, 1, 100)
        ol.translate3((0, 0, -10))
        ol.scale3((0.5, 0.5, 0.5))

        ol.rotate3Z(lux.time * pi * 0.01)
        ol.rotate3X(lux.time * pi * 0.025)
        ol.rotate3Y(lux.time * pi * 0.013)

        ol.color3(*(self.color_cycle()))

        ol.begin(ol.POINTS)
        decay_factor = 1
        first_point = None
        for i in range(self.SAMPLES_PER_FRAME):
            theta = float(i) / self.SAMPLES_PER_FRAME * self.MAX_THETA
            x = sin(self.x_ratio * theta + self.x_phase)
            y = sin(self.y_ratio * theta + self.y_phase)
            z = sin(self.z_ratio * theta + self.z_phase)
            if (i == 0):
                first_point = (x * decay_factor, y * decay_factor, z * decay_factor)
            ol.vertex3((x * decay_factor, y * decay_factor, z * decay_factor))
            decay_factor = decay_factor * self.decay
        ol.vertex3(first_point)
        ol.end()
Esempio n. 4
0
    def draw(self):

        self.x_phase = 0.4*cos(1.7 * lux.time * self.RATE) + 0.6*cos(0.7 * lux.time * self.RATE)
        self.y_phase = cos(2.2 * lux.time * self.RATE)
        self.z_phase = cos(5.7 * lux.time * self.RATE)
        self.z_ratio = 2 + cos(0.1 * lux.time * self.RATE)

        ol.loadIdentity3()
        ol.loadIdentity()

        ol.perspective(20, 1, 1, 100)
        ol.translate3((0, 0, -10))
        #ol.scale3((0.5, 0.5, 0.5))

        ol.rotate3Z(lux.time * pi * 0.01)
        ol.rotate3X(lux.time * pi * 0.025)
        ol.rotate3Y(lux.time * pi * 0.013)

        ol.color3(*(self.color_cycle()))

        ol.begin(ol.POINTS)
        decay_factor = 1
        first_point = None
        for i in range(self.SAMPLES_PER_FRAME):
            theta = float(i) / self.SAMPLES_PER_FRAME * self.MAX_THETA
            x = sin(self.x_ratio * theta + self.x_phase)
            y = sin(self.y_ratio * theta + self.y_phase)
            z = sin(self.z_ratio * theta + self.z_phase)
            if (i == 0):
                first_point = (x * decay_factor, y * decay_factor, z * decay_factor)
            ol.vertex3((x * decay_factor, y * decay_factor, z * decay_factor))
            decay_factor = decay_factor * self.decay
        ol.vertex3(first_point)
        ol.end()
Esempio n. 5
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        # Grab the raw audio buffers
        mono = audio_engine.left_buffer()
#        mono = np.zeros(512)

        # Make sure they aren't empty!!
        if (mono.shape[0] == 0):
            return

        # Openlase can only draw 30000 points in one cycle (less that
        # that, actually!).  Clear the audio buffer and try again!
        if mono.shape[0] > 10000:
            audio_engine.clear_all()
            return

        ol.loadIdentity3()
        ol.color3(*(self.color_cycle()))

        ol.begin(ol.LINESTRIP)
        for i in range(0, mono.shape[0]-1, self.subsamp):
            scale_factor = pow(0.9-abs(self.x_coord),0.5)*2
            if (mono[i] <= -1.0):
                mono[i] = 1.0
            ol.vertex3((self.x_coord, tanh(mono[i]*scale_factor), -1))
#            ol.vertex3((self.x_coord, log(mono[i]*scale_factor+1.0), -1))
            self.x_coord = self.x_coord + self.step
            if (self.x_coord > 0.9) : self.x_coord = -0.9
        ol.end()
Esempio n. 6
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        ol.loadIdentity3()
        ol.perspective(20, 1, 1, 100)
        ol.translate3((0, 0, -20))

        ol.color3(1.0,1.0,0.0);
        ol.translate3( (cos(lux.time/2.0), cos(lux.time/3.0), cos(lux.time/7.0)) )
        ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
        ol.rotate3X(lux.time * pi * 0.25 * lux.simple_rate)
        ol.rotate3Y(lux.time * pi * 0.13 * lux.simple_rate)
        

        for row in self.torender:
            ol.begin(ol.LINESTRIP)
            vi = self.faces[row]
            vi = vi + [vi[0]]

            for i in vi:
                tup = tuple(self.verts[i,:])
                ol.vertex3(tup)
            
            ol.end()
Esempio n. 7
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))

        ol.color3(1.0, 1.0, 1.0)

        offset = cos(lux.time * 10)
        ol.begin(ol.LINESTRIP)
        npts = 25
        #ol.scale3((0.5,0.5,0.5))
        for i in range(npts):
            ol.color3(
                float(i) / npts, 1.0 - float(i) / npts,
                (float(i) / npts + (1.0 - float(i) / npts)) / 2.0)
            offset = 0
            mod = (i % 2 * 2.0 - 1.0) * 0.99
            #ol.scale3((mod, mod, mod))
            ol.rotate3Z(lux.time * pi * 0.01 * lux.simple_rate)
            ol.vertex3((float(i) / (npts / 2.0) - 1.0 + offset, -1.0, -1))
            ol.vertex3((float(i) / (npts / 2.0) - 1.0 + offset, 1.0, -1))

        ol.end()
Esempio n. 8
0
    def draw(self, target=None):
        for particle in reversed(self.tail):
            # draw connecting lines
            if particle.follow:
                new_x, new_y = particle.follow.x, particle.follow.y
                if draw_links:
                    ol.color3(1, 0, 1)  # magenta links
                    ol.loadIdentity3()
                    ol.loadIdentity()
                    ol.begin(ol.LINESTRIP)
                    ol.vertex3((particle.x, particle.y, 0))
                    ol.vertex3((particle.follow.x, particle.follow.y, 0))
                    ol.end()
            else:
                if target: new_x, new_y = target[0], target[1]
                else:
                    new_x, new_y = math.cos(3 * lux.time), math.sin(2 *
                                                                    lux.time)
                #new_x, new_y = self.mouse_x, self.mouse_y
            particle.draw('blah')

            if abs(particle.x - new_x) > 0.01 or abs(particle.y -
                                                     new_y) > 0.01:
                self.tweener.add_tween(particle, x=new_x, y=new_y, duration=0.6, \
                    easing=pytweener.Easing.Cubic.ease_out, on_complete=particle.finish, on_update=particle.draw)
Esempio n. 9
0
def square(posx,posy,size):
    ol.begin(ol.LINESTRIP)
    ol.vertex3((posx,posy,0))
    ol.vertex3((posx+size,posy,0))
    ol.vertex3((posx+size,posy+size,0))
    ol.vertex3((posx,posy+size,0))
    ol.vertex3((posx,posy,0))
    ol.end()
Esempio n. 10
0
 def draw(self, color):
     ol.color3(color[0], color[1], color[2])
     # ol.begin(ol.LINESTRIP)
     try:
         ol.vertex3((self.prev_x, self.prev_y, 0))
     except AttributeError:
         pass
     ol.vertex3((self.x, self.y, 0))
Esempio n. 11
0
 def draw(self, color):
     ol.color3(color[0], color[1], color[2])
     #ol.begin(ol.LINESTRIP)
     try:
         ol.vertex3((self.prev_x,self.prev_y,0))
     except AttributeError:
         pass
     ol.vertex3((self.x, self.y, 0))
Esempio n. 12
0
    def draw(self):
        time = lux.time
        #time = self.time
        ctf = self.color_time_frequency
        clf = self.color_length_frequency
        caf = self.color_angle_frequency/2
        theta = abs(math.sin(time*self.time_scale))
        R = self.R * math.sin(2*pi*time*self.time_scale*self.R_frequency)
        r = self.r * math.sin(2*pi*time*self.time_scale*self.r_frequency)
        p = self.p * math.sin(2*pi*time*self.time_scale*self.p_frequency) * self.bass

        ol.color3(1.0, 0.0, 1.0);
        ol.loadIdentity3()
        ol.loadIdentity()
        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))
        
        first = True
        n = 0
        while theta < 2*pi*self.max_cycles and n < self.max_segments:
            theta += self.theta_step
            #x = (R + r) * math.cos(theta)
            #y = (R + r) * math.sin(theta)
            x = (R + r) * math.cos(theta) + (r + p) * math.cos((R+r)/r * theta)
            y = (R + r) * math.sin(theta) + (r + p) * math.sin((R+r)/r * theta)
            
            if first:
                ol.begin(ol.LINESTRIP)
                #ol.begin(ol.POINTS)
                first = False
            #red = math.sin(ctf*time*n/37) * math.sin(csf*theta*n/37)
            #green = math.sin(ctf*time*n/23) * math.sin(csf*theta*n/23)
            #blue = math.sin(ctf*time*n/128) * math.sin(csf*theta*n/128)
            
            angle = math.atan2(y, x)/(2*pi)
            red   = abs(math.sin(2*pi*(self.r_prime/3+ctf*time+clf*n+caf*angle)))
            green = abs(math.sin(2*pi*(self.g_prime/3+ctf*time+clf*n+caf*angle)))
            blue =  abs(math.sin(2*pi*(self.b_prime/3+ctf*time+clf*n+caf*angle)))
            ol.color3(red, green, blue)
            
            #this makes it square-ish
            #x += math.cos(2*pi*angle*self.spatial_resonance)*self.spatial_resonance_amplitude
            #y += math.sin(2*pi*angle*self.spatial_resonance)*self.spatial_resonance_amplitude
            x += math.cos(2*pi*angle*(self.spatial_resonance+1)+2*pi*self.spatial_resonance_offset)*self.spatial_resonance_amplitude
            y += math.sin(2*pi*angle*(self.spatial_resonance+1)+2*pi*self.spatial_resonance_offset)*self.spatial_resonance_amplitude


            x *= self.width
            y *= self.height
            ol.vertex3((x,y,0))
            n += 1
        ol.end()
        #dynamically adjust resolution
        target = self.max_segments * 0.8
        error = (target - n)/target
        self.theta_step = min(max(1e-100, self.theta_step * (1-error)), 1)
        #print n,  angle
        self.time += 1/30
Esempio n. 13
0
def square(x1,y1,x2,y2):
    
    ol.begin(ol.POINTS)
    ol.vertex3((x1,y1,0))
    ol.vertex3((x1,y2,0))
    ol.vertex3((x2,y2,0))        
    ol.vertex3((x2,y1,0))        
    ol.vertex3((x1,y1,0))  
    ol.end()
Esempio n. 14
0
def square(x1, y1, x2, y2):

    ol.begin(ol.POINTS)
    ol.vertex3((x1, y1, 0))
    ol.vertex3((x1, y2, 0))
    ol.vertex3((x2, y2, 0))
    ol.vertex3((x2, y1, 0))
    ol.vertex3((x1, y1, 0))
    ol.end()
Esempio n. 15
0
def square(posx, posy, size):
    ol.begin(ol.POINTS)
    # ol.begin(ol.LINESTRIP)
    ol.vertex3((posx, posy, 0))
    ol.vertex3((posx + size, posy, 0))
    ol.vertex3((posx + size, posy + size, 0))
    ol.vertex3((posx, posy + size, 0))
    ol.vertex3((posx, posy, 0))
    ol.end()
Esempio n. 16
0
    def square(self,x1,y1,x2,y2):

#        simple_rate = 3.0
#        ol.rotate3Z(lux.time * pi * 0.1 * simple_rate)
#        ol.rotate3X(lux.time * pi * 0.25 * simple_rate)
#        ol.rotate3Y(lux.time * pi * 0.13 * simple_rate)

        ol.begin(ol.LINESTRIP)
        ol.vertex3((x1,y1,0))
        ol.vertex3((x1,y2,0))
        ol.vertex3((x2,y2,0))        
        ol.vertex3((x2,y1,0))        
        ol.vertex3((x1,y1,0))  
        ol.end()
Esempio n. 17
0
    def square(self, x1, y1, x2, y2):

        #        simple_rate = 3.0
        #        ol.rotate3Z(lux.time * pi * 0.1 * simple_rate)
        #        ol.rotate3X(lux.time * pi * 0.25 * simple_rate)
        #        ol.rotate3Y(lux.time * pi * 0.13 * simple_rate)

        ol.begin(ol.LINESTRIP)
        ol.vertex3((x1, y1, 0))
        ol.vertex3((x1, y2, 0))
        ol.vertex3((x2, y2, 0))
        ol.vertex3((x2, y1, 0))
        ol.vertex3((x1, y1, 0))
        ol.end()
Esempio n. 18
0
    def draw(self):
        '''a square'''
        #self.x = math.cos(2*pi*rotate_frequency*lux.time + self.angle + self.base_angle) * self.distance * self.distance_scale
        #self.y = math.sin(2*pi*rotate_frequency*lux.time + self.angle + self.base_angle) * self.distance * self.distance_scale
        
        #stolen from guilloche
        time = lux.time * time_scale 
        R = math.sin(2*pi*self.R_frequency*time) * self.R + 0.0001
        r = math.sin(2*pi*self.r_frequency*time) * self.r + 0.0001
        p = math.sin(2*pi*self.p_frequency*time) * self.p + 0.0001
        self.x = (R + r) * math.cos(time) + (r + p) * math.cos((R+r)/r * time) 
        self.y = (R + r) * math.sin(time) + (r + p) * math.sin((R+r)/r * time) 
        
        #clamp to display area
        if clamp_display:
            if self.x > 1: self.x = 1
            if self.y > 1: self.y = 1
            if self.x < -1: self.x = -1
            if self.y < -1: self.y = -1
        self.x *= scale
        self.y *= scale
        #self.graphics.circle(0, 0, self.radius)
        ol.loadIdentity3()
        ol.loadIdentity()


        #ol.color3(self.color[0], self.color[1], self.color[2])
        ol.color3(self.red, self.green, self.blue)
        ol.translate3((self.x, self.y, 0))
        angle = math.atan2(self.y, self.x)/(2*pi)
        red   = abs(math.sin(2*pi*(r_prime/3+ctf*time+clf*self.n+caf*angle)))*self.red
        green = abs(math.sin(2*pi*(g_prime/3+ctf*time+clf*self.n+caf*angle)))*self.green
        blue =  abs(math.sin(2*pi*(b_prime/3+ctf*time+clf*self.n+caf*angle)))*self.blue
        if seizure_mode:
          #red, green, blue = red/self.radius, green/self.radius, blue/self.radius
          red = abs(red*math.tan((2*pi*self.radius/node_big_radius)))
          green = abs(green*math.tan((2*pi*self.radius/node_big_radius)))
          blue = abs(blue*math.tan((2*pi*self.radius/node_big_radius)))
        
        ol.color3(red, green, blue)
 
        #do squares have radii?
        s = self.radius
        ol.begin(ol.POINTS)
        ol.vertex3((-s, s,0))
        ol.vertex3((-s, s,0))
        ol.vertex3(( s, s,0))
        ol.vertex3(( s,-s,0))
        ol.vertex3((-s,-s,0))
        ol.end()
Esempio n. 19
0
    def draw(self, val):
        '''a square'''
        ol.loadIdentity3()
        ol.loadIdentity()
        ol.color3(self.color[0], self.color[1], self.color[2])
        ol.translate3((self.x, self.y, 0))
        ol.begin(ol.POINTS)
        ol.vertex3((.0, .0, .0))
        ol.vertex3((.0, .1, .0))
        ol.vertex3((.1, .1, .0))
        ol.vertex3((.1, .0, .0))
        ol.vertex3((.0, .0, .0))
        ol.end()

        self.moving = True
        return self
Esempio n. 20
0
  def draw(self, val):
    '''a square'''
    ol.loadIdentity3()
    ol.loadIdentity()
    ol.color3(self.color[0], self.color[1], self.color[2])
    ol.translate3((self.x, self.y, 0))
    ol.begin(ol.POINTS)
    ol.vertex3((.0,.0,.0))
    ol.vertex3((.0,.1,.0))
    ol.vertex3((.1,.1,.0))
    ol.vertex3((.1,.0,.0))
    ol.vertex3((.0,.0,.0))
    ol.end()

    self.moving = True
    return self
Esempio n. 21
0
    def draw(self):
        time = lux.time
        ctf = self.color_time_frequency
        clf = self.color_length_frequency
        caf = self.color_angle_frequency/2
        theta0 = abs(math.sin(time*self.time_scale))

        
        for braid_count in range(1,self.NUM_CIRCLES):
            first = True
            n = 0
            theta = theta0
            
            ol.color3(1.0, 0.0, 1.0);
            ol.loadIdentity3()
            ol.loadIdentity()
            ol.perspective(40, 1, 1, 100)
            ol.translate3((0, 0, -3))
            ol.rotate3Z(lux.time * pi * self.z_rotations[braid_count])
            ol.rotate3X(lux.time * pi * self.x_rotations[braid_count])
            ol.rotate3Z(lux.time * pi * self.x_rotations[braid_count])

            ol.begin(ol.LINESTRIP)
            while theta < theta0 + 2*pi:

                r = (0.5+sin(10*theta)/2.0) / float(braid_count) * self.scale
                x = r * cos(theta)
                y = r * sin(theta)

                angle = math.atan2(y, x)/(2*pi)
                red   = abs(math.sin(2*pi*(self.r_prime/3+ctf*time+clf*n+caf*angle)+self.color_phases[braid_count]))
                green = abs(math.sin(2*pi*(self.g_prime/3+ctf*time+clf*n+caf*angle)+self.color_phases[braid_count]))
                blue =  abs(math.sin(2*pi*(self.b_prime/3+ctf*time+clf*n+caf*angle)+self.color_phases[braid_count]))
                ol.color3(red, green, blue)
                ol.vertex3((x,y,0))
                n += 1

                theta += 1.0/float(self.max_segments)

            r = (0.5+sin(10*theta)/2.0) / float(braid_count) * self.scale
            x = r * cos(theta)
            y = r * sin(theta)
            ol.vertex3((x,y,0))  # Close the path
            ol.end()
Esempio n. 22
0
    def draw(self):

        a = self.alpha * cos(lux.time / 10.0 * self.RATE)
        b = self.beta * sin(lux.time / 7.0 * self.RATE) + 10
        c = self.gamma * cos(lux.time / 11.0 * self.RATE)
        A = self.rho

        ol.loadIdentity3()
        ol.loadIdentity()
        ol.rotate3Z(lux.time * pi * 0.03)
        ol.color3(*(self.color_cycle()))

        ol.begin(ol.LINESTRIP)
        for i in range(self.SAMPLES_PER_FRAME):
            theta = float(i) / self.SAMPLES_PER_FRAME * self.MAX_THETA
            r = exp(cos(a * theta)) - A * cos(b*theta) + pow(abs(sin(theta/c)),b)
            r = r / (2.7 - A + pow(1,b)) * self.overall_amplitude

            ol.vertex3((r * cos(theta), r * sin(theta), -1))
        ol.end()
Esempio n. 23
0
    def draw(self):
        ol.loadIdentity()

        ol.color3(1.0, 1.0, 1.0)

        # bounding box
        ol.begin(ol.LINESTRIP)
        self.square(1, 1, -1, -1)
        ol.end()

        # horizontal line
        ol.begin(ol.LINESTRIP)
        ol.vertex((-1, 0))
        ol.vertex((1, 0))
        ol.end()

        # vertical line
        ol.begin(ol.LINESTRIP)
        ol.vertex((0, -1))
        ol.vertex((0, 1))
        ol.end()

        # inner box, for fun
        ol.color3(0.0, 1.0, 0.0)
        size = (sin(lux.time) * .2) + .5
        ol.begin(ol.LINESTRIP)
        self.square(size, size, -size, -size)
        ol.end()

        # Red dots
        ol.loadIdentity()
        ol.loadIdentity3()

        ol.begin(ol.LINESTRIP)
        for y in range(0, 20):
            ol.color3(float(y) / 20.0, 0.0, 0.0)
            ol.vertex3((-0.6, (float(y - 10) / 12.0), -1.0))
        ol.end()

        # Green dots
        ol.begin(ol.LINESTRIP)
        for y in range(0, 20):
            ol.color3(0.0,
                      float(y) / 20.0, 0.0)
            ol.vertex3((-0.4, (float(y - 10) / 12.0), -1.0))
        ol.end()

        # Blue dots
        ol.begin(ol.LINESTRIP)
        for y in range(0, 20):
            ol.color3(0.0, 0.0,
                      float(y) / 20.0)
            ol.vertex3((-0.2, (float(y - 10) / 12.0), -1.0))
        ol.end()

        # vertical line
        ol.begin(ol.LINESTRIP)
        ol.vertex((0, -1))
        ol.vertex((0, 1))
        ol.end()
Esempio n. 24
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        # Grab the raw audio buffers
        mono = audio_engine.left_buffer()
        #        mono = np.zeros(512)

        # Make sure they aren't empty!!
        if (mono.shape[0] == 0):
            return

        # Openlase can only draw 30000 points in one cycle (less that
        # that, actually!).  Clear the audio buffer and try again!
        if mono.shape[0] > 10000:
            audio_engine.clear_all()

        ol.loadIdentity3()
        ol.color3(*(self.color_cycle()))

        count = 0
        while count < mono.shape[0]:

            ol.begin(ol.LINESTRIP)
            while self.x_coord < 1.0 and count < mono.shape[0]:

                scale_factor = pow(1.0 - abs(self.x_coord), 0.5) * 2
                #ol.vertex3((self.x_coord, mono[count]*scale_factor, -1))             # Linear
                ol.vertex3((self.x_coord, tanh(mono[count] * scale_factor),
                            -1))  # Tanh
                #ol.vertex3((self.x_coord, log(mono[count]*scale_factor+1.0), -1))    # Sigmoid

                self.x_coord += self.step
                count = count + self.subsamp
            ol.end()

            if self.x_coord >= 1.0:
                self.x_coord = -1.0

        ol.end()
Esempio n. 25
0
  def draw(self, target = None):
    for particle in reversed(self.tail):
        # draw connecting lines
        if particle.follow:
            new_x, new_y = particle.follow.x, particle.follow.y
            if draw_links:
                ol.color3(1,0,1) # magenta links
                ol.loadIdentity3()
                ol.loadIdentity()
                ol.begin(ol.LINESTRIP)
                ol.vertex3((particle.x, particle.y, 0))
                ol.vertex3((particle.follow.x, particle.follow.y, 0))
                ol.end()
        else:
            if target: new_x, new_y = target[0], target[1]
            else: new_x, new_y = math.cos(3*lux.time), math.sin(2*lux.time)
            #new_x, new_y = self.mouse_x, self.mouse_y
        particle.draw('blah')

        if abs(particle.x - new_x) > 0.01 or abs(particle.y - new_y) > 0.01:
            self.tweener.add_tween(particle, x=new_x, y=new_y, duration=0.6, \
                easing=pytweener.Easing.Cubic.ease_out, on_complete=particle.finish, on_update=particle.draw)
Esempio n. 26
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        # Grab the raw audio buffers
        mono = audio_engine.left_buffer()
#        mono = np.zeros(512)

        # Make sure they aren't empty!!
        if (mono.shape[0] == 0):
            return

        # Openlase can only draw 30000 points in one cycle (less that
        # that, actually!).  Clear the audio buffer and try again!
        if mono.shape[0] > 10000:
            audio_engine.clear_all()
 
        ol.loadIdentity3()
        ol.color3(*(self.color_cycle()))

        count = 0
        while count < mono.shape[0]:

            ol.begin(ol.LINESTRIP)
            while self.x_coord < 1.0 and count < mono.shape[0]:

                scale_factor = pow(1.0-abs(self.x_coord),0.5)*2
                #ol.vertex3((self.x_coord, mono[count]*scale_factor, -1))             # Linear
                ol.vertex3((self.x_coord, tanh(mono[count]*scale_factor), -1))        # Tanh
                #ol.vertex3((self.x_coord, log(mono[count]*scale_factor+1.0), -1))    # Sigmoid
                
                self.x_coord += self.step
                count = count + self.subsamp
            ol.end()

            if self.x_coord >= 1.0:
                self.x_coord = -1.0
                
        ol.end()
Esempio n. 27
0
    def draw(self):
        ol.loadIdentity()

        ol.color3(1.0, 1.0, 1.0);

        # bounding box
        ol.begin(ol.LINESTRIP)
        self.square(1,1,-1,-1)
        ol.end()
        
        # horizontal line
        ol.begin(ol.LINESTRIP)
        ol.vertex((-1,0))
        ol.vertex((1,0))        
        ol.end()

        # vertical line
        ol.begin(ol.LINESTRIP)
        ol.vertex((0,-1))
        ol.vertex((0,1))        
        ol.end()

        # inner box, for fun
        ol.color3(0.0, 1.0, 0.0);
        size = (sin(lux.time) * .2)+.5
        ol.begin(ol.LINESTRIP)
        self.square(size,size,-size,-size)
        ol.end()

        # Red dots
        ol.loadIdentity()
        ol.loadIdentity3()

        ol.begin(ol.LINESTRIP)
        for y in range(0, 20):
            ol.color3(float(y)/20.0, 0.0, 0.0);
            ol.vertex3((-0.6, (float(y-10) / 12.0), -1.0))
        ol.end()

        # Green dots
        ol.begin(ol.LINESTRIP)
        for y in range(0, 20):
            ol.color3(0.0, float(y)/20.0, 0.0);
            ol.vertex3((-0.4, (float(y-10) / 12.0), -1.0))
        ol.end()

        # Blue dots
        ol.begin(ol.LINESTRIP)
        for y in range(0, 20):
            ol.color3(0.0, 0.0, float(y)/20.0);
            ol.vertex3((-0.2, (float(y-10) / 12.0), -1.0))
        ol.end()

        # vertical line
        ol.begin(ol.LINESTRIP)
        ol.vertex((0,-1))
        ol.vertex((0,1))        
        ol.end()
Esempio n. 28
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))

        ol.color3(1.0,1.0,1.0)

        offset = cos(lux.time*10)
        ol.begin(ol.LINESTRIP)
        npts = 25
        #ol.scale3((0.5,0.5,0.5))
        for i in range(npts):
            ol.color3(float(i)/npts,1.0-float(i)/npts,(float(i)/npts+(1.0-float(i)/npts))/2.0)
            offset = 0
            mod = (i%2 * 2.0 - 1.0) * 0.99
            #ol.scale3((mod, mod, mod))
            ol.rotate3Z(lux.time * pi * 0.01 * lux.simple_rate)
            ol.vertex3((float(i)/(npts/2.0)-1.0+offset,-1.0,-1))
            ol.vertex3((float(i)/(npts/2.0)-1.0+offset,1.0,-1))

        ol.end()
Esempio n. 29
0
    def draw(self):
        try:
            a = self.alpha * cos(lux.time / 10.0 * self.RATE)
            b = self.beta * sin(lux.time / 7.0 * self.RATE) + 10
            c = self.gamma * cos(lux.time / 11.0 * self.RATE)
            A = self.rho

            ol.loadIdentity3()
            ol.loadIdentity()
            ol.rotate3Z(lux.time * pi * 0.03)
            ol.color3(*(self.color_cycle()))

            ol.begin(ol.LINESTRIP)
            for i in range(self.SAMPLES_PER_FRAME):
                theta = float(i) / self.SAMPLES_PER_FRAME * self.MAX_THETA
                r = exp(cos(a * theta)) - A * cos(b * theta) + pow(
                    abs(sin(theta / c)), b)
                r = r / (2.7 - A + pow(1, b)) * self.overall_amplitude

                ol.vertex3((self.SCALE * r * cos(theta),
                            self.SCALE * r * sin(theta), -1))
            ol.end()
        except ValueError:
            pass  # Occasinal math hiccups can be safely ignored
Esempio n. 30
0
 def draw(self):
     if self.lines_only:
         ol.begin(ol.LINESTRIP)
         x, y =  self.segments[0].start
         ol.vertex3((x, y, 0), self.color)
         for i in self.segments:
             ol.vertex3((i.end[0], i.end[1], 0), self.color)
         ol.end()
     else:
         ol.begin(ol.BEZIERSTRIP)
         x, y = self.segments[0].start
         ol.vertex3((x, y, 0), self.color)
         for i in self.segments:
             i = i.to_bezier4()
             ol.vertex3((i.cp1[0], i.cp1[1], 0), self.color)
             ol.vertex3((i.cp2[0], i.cp2[1], 0), self.color)
             ol.vertex3((i.end[0], i.end[1], 0), self.color)
         ol.end()
Esempio n. 31
0
    def draw(self):

        self.i = self.i + 1.0

        #inverse persistence length
        self.thetad = 0.25 * (1.0 + sin(2.0 * pi * self.i / 2000.0))

        #RGB curliness offset
        offset = pi / 6.0

        #RGB curly-straight cycle frequency
        crlstrt = 0.005

        #RGB maximum curlyness
        curlmx = 0.2

        theta0B = curlmx * cos(self.i * crlstrt)
        theta0R = curlmx * cos(self.i * crlstrt + offset)
        theta0G = curlmx * cos(self.i * crlstrt + 2.0 * offset)

        self.thetaB = self.thetaB + random.gauss(theta0B, self.thetad)
        self.thetaR = self.thetaR + random.gauss(theta0R, self.thetad)
        self.thetaG = self.thetaG + random.gauss(theta0G, self.thetad)

        self.BX = np.append(self.BX[1:],
                            self.BX[-1] + self.dr * cos(self.thetaB))
        self.BY = np.append(self.BY[1:],
                            self.BY[-1] + self.dr * sin(self.thetaB))

        self.RX = np.append(self.RX[1:],
                            self.RX[-1] + self.dr * cos(self.thetaR))
        self.RY = np.append(self.RY[1:],
                            self.RY[-1] + self.dr * sin(self.thetaR))

        self.GX = np.append(self.GX[1:],
                            self.GX[-1] + self.dr * cos(self.thetaG))
        self.GY = np.append(self.GY[1:],
                            self.GY[-1] + self.dr * sin(self.thetaG))

        # derivative roughness parameter
        # b=0.1;
        # if b != 0.0:
        #     [Fx,Fy]=gradient([self.BX;self.RX;self.GX;self.BY;self.RY;self.GY])

        #     self.BX=b*Fx(4,:)+self.BX
        #     self.RX=b*Fx(5,:)+self.RX
        #     self.GX=b*Fx(6,:)+self.GX

        #     self.BY=b*Fx(1,:)+self.BY
        #     self.RY=b*Fx(2,:)+self.RY
        #     self.GY=b*Fx(3,:)+self.GY

        #combine paths
        rmult = 0.0001
        if 1:
            fmB = 0.5
            fmG = 0.5

            #            self.BX=(self.BX+self.RX+(2*random.uniform(1,self.N)-1.0)*rmult)/2.0
            self.BX = (self.BX + self.RX) / 2.0
            self.BY = (self.BY + self.RY +
                       (2 * random.uniform(1, self.N) - 1.0) * rmult) / 2.0

            self.RX = (self.RX + self.GX +
                       (2 * random.uniform(1, self.N) - 1.0) * rmult) / 2.0
            self.RY = (self.RY + self.GY +
                       (2 * random.uniform(1, self.N) - 1.0) * rmult) / 2.0

            self.GX = (self.BX + self.GX +
                       (2 * random.uniform(1, self.N) - 1.0) * rmult) / 2.0
            self.GY = (self.BY + self.GY +
                       (2 * random.uniform(1, self.N) - 1.0) * rmult) / 2.0
        else:
            fmB = 1.0
            fmG = 1.0

        #spin frequency
        freq = 0.01 + random.gauss(0, 0.002)

        self.BX = cos(freq * fmB) * self.BX - sin(freq * fmB) * self.BY
        self.BY = sin(freq * fmB) * self.BX + cos(freq * fmB) * self.BY

        self.RX = cos(freq) * self.RX - sin(freq) * self.RY
        self.RY = sin(freq) * self.RX + cos(freq) * self.RY

        self.GX = cos(freq * fmG) * self.GX - sin(freq * fmG) * self.GY
        self.GY = sin(freq * fmG) * self.GX + cos(freq * fmG) * self.GY

        #centering
        self.BX = self.BX - self.BX.mean()
        self.BY = self.BY - self.BY.mean()

        self.RX = self.RX - self.RX.mean()
        self.RY = self.RY - self.RY.mean()

        self.GX = self.GX - self.GX.mean()
        self.GY = self.GY - self.GY.mean()

        #scaling and bouncy factor
        bounce = 5.0
        self.fB = self.fB + (
            (self.fB + max(np.sqrt(self.BX**2 + self.BY**2))) / 2.0 -
            self.fB) / bounce
        self.fR = self.fR + (
            (self.fR + max(np.sqrt(self.RX**2 + self.RY**2))) / 2.0 -
            self.fR) / bounce
        self.fG = self.fG + (
            (self.fG + max(np.sqrt(self.GX**2 + self.GY**2))) / 2.0 -
            self.fG) / bounce

        self.BX = self.BX / self.fB
        self.BY = self.BY / self.fB

        self.RX = self.RX / self.fR
        self.RY = self.RY / self.fR

        self.GX = self.GX / self.fG
        self.GY = self.GY / self.fG

        ####################################
        #LUX RENDERING CODE
        ####################################

        ol.loadIdentity3()
        ol.loadIdentity()
        #        ol.color3(*(self.color_cycle()))
        ol.scale3((self.scale_factor, self.scale_factor, self.scale_factor))
        theta_rot = 0.4 * cos(1.7 * lux.time * self.ROT_RATE) + 0.6 * cos(
            0.7 * lux.time * self.ROT_RATE)
        ol.rotate3Z(theta_rot)

        render_type = ol.POINTS

        current_hue_marker = self.writhe_current_hue
        current_hue_target = self.writhe_hue_target
        current_hue_step = self.writhe_hue_step

        #        ol.color3(0.0,0.0,1.0)
        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((self.BX[i], self.BY[i], -1))
        ol.end()

        self.writhe_current_hue = current_hue_marker
        self.writhe_current_target = current_hue_target
        self.writhe_current_step = current_hue_step

        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((-self.BX[i], self.BY[i], -1))
        ol.end()

        self.writhe_current_hue = current_hue_marker
        self.writhe_current_target = current_hue_target
        self.writhe_current_step = current_hue_step

        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((self.BX[i], -self.BY[i], -1))
        ol.end()

        self.writhe_current_hue = current_hue_marker
        self.writhe_current_target = current_hue_target
        self.writhe_current_step = current_hue_step

        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((-self.BX[i], -self.BY[i], -1))
        ol.end()
Esempio n. 32
0
    def draw(self, audio):
        '''a square'''
        #self.x = math.cos(2*pi*rotate_frequency*lux.time + self.angle + self.base_angle) * self.distance * self.distance_scale
        #self.y = math.sin(2*pi*rotate_frequency*lux.time + self.angle + self.base_angle) * self.distance * self.distance_scale
        
        #stolen from guilloche
        time = lux.time * time_scale 
        R = math.sin(2*pi*self.R_frequency*time) * self.R + 0.0001
        r = math.sin(2*pi*self.r_frequency*time) * self.r + 0.0001
        p = math.sin(2*pi*self.p_frequency*time) * self.p + 0.0001
        self.x = (R + r) * math.cos(time) + (r + p) * math.cos((R+r)/r * time) 
        self.y = (R + r) * math.sin(time) + (r + p) * math.sin((R+r)/r * time) 
        
        #clamp to display area
        if clamp_display:
            if self.x > 1: self.x = 1
            if self.y > 1: self.y = 1
            if self.x < -1: self.x = -1
            if self.y < -1: self.y = -1
        self.x *= scale
        self.y *= scale
        #self.graphics.circle(0, 0, self.radius)
        ol.loadIdentity3()
        ol.loadIdentity()


        #ol.color3(self.color[0], self.color[1], self.color[2])
        ol.color3(self.red, self.green, self.blue)
        ol.translate3((self.x, self.y, 0))
        angle = math.atan2(self.y, self.x)/(2*pi)
        red   = self.red #abs(math.sin(2*pi*(r_prime/3+ctf*time+clf*self.n+caf*angle)))*self.red
        green = abs(math.sin(2*pi*(g_prime/3+ctf*time+clf*self.n+caf*angle)))*self.green
        blue =  abs(math.sin(2*pi*(b_prime/3+ctf*time+clf*self.n+caf*angle)))*self.blue
        if seizure_mode:
          #red, green, blue = red/self.radius, green/self.radius, blue/self.radius
          red = abs(red*math.tan((2*pi*self.radius/node_big_radius)))
          green = abs(green*math.tan((2*pi*self.radius/node_big_radius)))
          blue = abs(blue*math.tan((2*pi*self.radius/node_big_radius)))
        if audio:   
                try:
                  #seems most of the time all the samples are empty
		  #sample_index = int((self.n/max_nodes)*audio[0].shape[0])
                  sample_index = 0 #self.n
	          sample = audio[0][n]

                except: sample = 1
        else: sample = 1 #[0 for x in range(10000)] #empty vector 
        #print sample 
        if audio:
          red = red
          blue = blue + sample*self.audio_gain
          green = green + sample*self.audio_gain
        ol.color3(red, green, blue)
	if self.last_sample - sample > 0.1:
          pass #pulse 
        #do squares have radii?
        s = self.radius
        ol.begin(ol.POINTS)
        ol.vertex3((-s, s,0))
        ol.vertex3((-s, s,0))
        ol.vertex3(( s, s,0))
        ol.vertex3(( s,-s,0))
        ol.vertex3((-s,-s,0))
        ol.end()
Esempio n. 33
0
	font = ol.getDefaultFont()
	s = "Hi!"
	w = ol.getStringWidth(font, 0.2, s)
	ol.drawString(font, (-w/2,0.1), 0.2, ol.C_WHITE, s)

	ol.perspective(60, 1, 1, 100)
	ol.translate3((0, 0, -3))

	for i in range(2):
		ol.scale3((0.6, 0.6, 0.6))
		ol.rotate3Z(time * pi * 0.1)
		ol.rotate3X(time * pi * 0.8)
		ol.rotate3Y(time * pi * 0.73)

		ol.begin(ol.LINESTRIP)
		ol.vertex3((-1, -1, -1), ol.C_WHITE)
		ol.vertex3(( 1, -1, -1), ol.C_WHITE)
		ol.vertex3(( 1,  1, -1), ol.C_WHITE)
		ol.vertex3((-1,  1, -1), ol.C_WHITE)
		ol.vertex3((-1, -1, -1), ol.C_WHITE)
		ol.vertex3((-1, -1,  1), ol.C_WHITE)
		ol.end()

		ol.begin(ol.LINESTRIP);
		ol.vertex3(( 1,  1,  1), ol.C_WHITE)
		ol.vertex3((-1,  1,  1), ol.C_WHITE)
		ol.vertex3((-1, -1,  1), ol.C_WHITE)
		ol.vertex3(( 1, -1,  1), ol.C_WHITE)
		ol.vertex3(( 1,  1,  1), ol.C_WHITE)
		ol.vertex3(( 1,  1, -1), ol.C_WHITE)
		ol.end()
Esempio n. 34
0
    def draw(self):
        time = lux.time
        #time = self.time
        ctf = self.color_time_frequency
        clf = self.color_length_frequency
        caf = self.color_angle_frequency/2
        theta = abs(math.sin(time*self.time_scale))
        R = self.R * math.sin(2*pi*time*self.time_scale*self.R_frequency)
        r = self.r * math.sin(2*pi*time*self.time_scale*self.r_frequency)
        p = self.p * math.sin(2*pi*time*self.time_scale*self.p_frequency) * self.bass
        audio = self.get_audio()

        ol.color3(1.0, 0.0, 1.0);
        ol.loadIdentity3()
        ol.loadIdentity()
        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))
        
        first = True
        n = 0
        while theta < 2*pi*self.max_cycles and n < self.max_segments:
            theta += self.theta_step
            if audio:
                try:
                  sample_index = int(theta/(2*pi*self.max_cycles)*(audio[0].shape[0]-1))+1 #skip first sample
                  sample = audio[2][sample_index]
                except: sample = 0
            else: sample = 0 #[0 for x in range(10000)] #empty vector
            #x = (R + r) * math.cos(theta)
            #y = (R + r) * math.sin(theta)
            sample *= self.audio_gain
		#print sample
            #x = (R + r) * math.cos(theta) + (r + p + sample) * math.cos((R+r)/r * theta)
            #y = (R + r) * math.sin(theta) + (r + p + sample) * math.sin((R+r)/r * theta)
            #ben's ill advised DALT change
	    x = (R + r) * math.cos(theta) + (r + p * sample) * math.cos((R+r)/r * theta)
            y = (R + r) * math.sin(theta) + (r + p * sample) * math.sin((R+r)/r * theta)
            
            if first:
                #ol.begin(ol.LINESTRIP)
                ol.begin(ol.POINTS)
                first = False
            #red = math.sin(ctf*time*n/37) * math.sin(csf*theta*n/37)
            #green = math.sin(ctf*time*n/23) * math.sin(csf*theta*n/23)
            #blue = math.sin(ctf*time*n/128) * math.sin(csf*theta*n/128)
            
            angle = math.atan2(y, x)/(2*pi)
            red   = abs(math.sin(2*pi*(self.r_prime/3+ctf*time+clf*n+caf*angle)))
            green = abs(math.sin(2*pi*(self.g_prime/3+ctf*time+clf*n+caf*angle)))
            blue =  abs(math.sin(2*pi*(self.b_prime/3+ctf*time+clf*n+caf*angle)))
            ol.color3(red, green, blue)
            
            #this makes it square-ish
            #x += math.cos(2*pi*angle*self.spatial_resonance)*self.spatial_resonance_amplitude
            #y += math.sin(2*pi*angle*self.spatial_resonance)*self.spatial_resonance_amplitude
            x += math.cos(2*pi*angle*(self.spatial_resonance+1)+2*pi*self.spatial_resonance_offset)*self.spatial_resonance_amplitude
            y += math.sin(2*pi*angle*(self.spatial_resonance+1)+2*pi*self.spatial_resonance_offset)*self.spatial_resonance_amplitude


            x *= self.width
            y *= self.height
            ol.vertex3((x,y,0))
            n += 1
        ol.end()
        #dynamically adjust resolution
        target = self.max_segments * 0.8
        error = (target - n)/target
        self.theta_step = min(max(1e-100, self.theta_step * (1-error)), 1)
        #print n,  angle
        self.time += 1/30
Esempio n. 35
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        #ol.color3(1.0, 0.0, 1.0);
        #font = ol.getDefaultFont()
        #s = "Lux!"
        #w = ol.getStringWidth(font, 0.2, s)
        #ol.drawString(font, (-w/2,0.1), 0.2, s)

        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))


        #Dodecahedron---------------------------
        ol.color3(1.0,1.0,1.0);
        ol.scale3((0.8, 0.8, 0.8))
        ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
        ol.rotate3X(lux.time * pi * 0.8 * lux.simple_rate)
        ol.rotate3Y(lux.time * pi * 0.73 * lux.simple_rate)

        for face in self.dodeca_face_edges:
            ol.begin(ol.LINESTRIP)
            ol.vertex3(face[0])
            ol.vertex3(face[1])
            ol.vertex3(face[2])
            ol.vertex3(face[3])
            ol.vertex3(face[4])
            ol.vertex3(face[0])
            ol.end()

        #Icosahedron---------------------------
        ol.color3(1.0,1.0,0.0);
                    
        ol.scale3((0.9, 0.9, 0.9))
        ol.rotate3Z(lux.time * pi * 0.5 * lux.simple_rate)
        #ol.rotate3X(lux.time * pi * 0.8 * lux.simple_rate)
        #ol.rotate3Y(lux.time * pi * 0.73 * lux.simple_rate)

        for face in self.icos_face_edges:
            ol.begin(ol.LINESTRIP)
            ol.vertex3(face[0])
            ol.vertex3(face[1])
            ol.vertex3(face[2])
            ol.vertex3(face[0])
            ol.end()
        #for strip in self.icos_face_edges:
        #    ol.begin(ol.LINESTRIP)
        #    for f in strip:
        #        ol.vertex3(f)
        #    ol.end()

        #Cube---------------------------
#         ol.color3(0.0,0.0,1.0);
#         ol.scale3((0.4, 0.4, 0.4))
#         #ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
#         #ol.rotate3X(lux.time * pi * 0.8 * lux.simple_rate)
#         ol.rotate3Y(lux.time * pi * 0.73 * lux.simple_rate)

#         ol.begin(ol.LINESTRIP)
#         ol.vertex3((-1, -1, -1))
#         ol.vertex3(( 1, -1, -1))
#         ol.vertex3(( 1,  1, -1))
#         ol.vertex3((-1,  1, -1))
#         ol.vertex3((-1, -1, -1))
#         ol.vertex3((-1, -1,  1))
#         ol.end()
        
#         ol.begin(ol.LINESTRIP);
#         ol.vertex3(( 1,  1,  1))
#         ol.vertex3((-1,  1,  1))
#         ol.vertex3((-1, -1,  1))
#         ol.vertex3(( 1, -1,  1))
#         ol.vertex3(( 1,  1,  1))
#         ol.vertex3(( 1,  1, -1))
#         ol.end()
        
#         ol.begin(ol.LINESTRIP)
#         ol.vertex3(( 1, -1, -1))
#         ol.vertex3(( 1, -1,  1))
#         ol.end()
        
#         ol.begin(ol.LINESTRIP)
#         ol.vertex3((-1,  1,  1))
#         ol.vertex3((-1,  1, -1))
#         ol.end()

        #Octahedron------------------------
        ol.color3(0.0,0.0,1.0);
        ol.scale3((.8, .8, .8))
        #ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
        ol.rotate3X(lux.time * pi * 0.8 * lux.simple_rate)
        #ol.rotate3Y(lux.time * pi * 0.73 * lux.simple_rate)

        for strip in self.octahedron_face_edges:
            ol.begin(ol.LINESTRIP)
            for f in strip:
                ol.vertex3(f)
            ol.end()
Esempio n. 36
0
    def draw(self):
        theta = arange(0, 2 * pi, 2 * pi / self.N)

        # rotations in q-space
        mu = 0.01
        std = 0.001

        dth1 = random.gauss(mu, std)
        dth2 = random.gauss(mu, std)
        dth3 = random.gauss(mu, std)
        dth4 = random.gauss(mu, std)
        dth5 = random.gauss(mu, std)

        dth1b = random.gauss(mu, std)
        dth2b = random.gauss(mu, std)
        dth3b = random.gauss(mu, std)
        dth4b = random.gauss(mu, std)
        dth5b = random.gauss(mu, std)

        # dth1=self.dtheta*(1-2*(random.random()<self.cut));
        # dth2=self.dtheta*(1-2*(random.random()<self.cut));
        # dth3=self.dtheta*(1-2*(random.random()<self.cut));
        # dth4=self.dtheta*(1-2*(random.random()<self.cut));
        # dth5=self.dtheta*(1-2*(random.random()<self.cut));

        # dth1b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth2b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth3b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth4b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth5b=self.dtheta*(1-2*(random.random()<self.cut));

        self.th1 = self.th1 + dth1
        self.th2 = self.th2 + dth2
        self.th3 = self.th3 + dth3
        self.th4 = self.th4 + dth4
        self.th5 = self.th5 + dth5

        self.th1b = self.th1b + dth1b
        self.th2b = self.th2b + dth2b
        self.th3b = self.th3b + dth3b
        self.th4b = self.th4b + dth4b
        self.th5b = self.th5b + dth5b

        c1 = self.m1 * cos(self.th1)
        s1 = self.m1 * sin(self.th1)
        c2 = self.m2 * cos(self.th2)
        s2 = self.m2 * sin(self.th2)
        c3 = self.m3 * cos(self.th3)
        s3 = self.m3 * sin(self.th3)
        c4 = self.m4 * cos(self.th4)
        s4 = self.m4 * sin(self.th4)
        c5 = self.m5 * cos(self.th5)
        s5 = self.m5 * sin(self.th5)

        X = c1 * cos(theta + self.th1b) + c2 * cos(
            2 * theta +
            self.th2b) + c3 * cos(3 * theta + self.th3b) + c4 * cos(
                4 * theta + self.th4b) + c5 * cos(5 * theta + self.th5b)
        Y = s1 * sin(theta + self.th1b) + s2 * sin(
            2 * theta +
            self.th2b) + s3 * sin(3 * theta + self.th3b) + s4 * sin(
                4 * theta + self.th4b) + s5 * sin(5 * theta + self.th5b)

        X = (X - X.mean()).astype("complex")
        Y = (Y - Y.mean()).astype("complex")

        s = arange(1, self.N + 1, 1)

        Xtemp = X**self.p1x * Y**self.p1y + 2 * s * 1j - self.N * 1j
        Ytemp = X**self.p2x * Y**self.p2y + 2 * s * 1j - self.N * 1j

        X = Xtemp.real
        Y = Ytemp.real

        X = tanh(2 * X)
        Y = tanh(2 * Y)

        ol.loadIdentity3()
        ol.loadIdentity()
        ol.color3(*(self.color_cycle()))

        render_type = ol.POINTS

        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((X[i], Y[i], -1))
        ol.vertex3((X[0], Y[0], -1))
        ol.end()

        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((-X[i], Y[i], -1))
        ol.vertex3((-X[0], Y[0], -1))
        ol.end()

        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((0.7 * X[i], -0.7 * Y[i], -1))
        ol.vertex3((0.7 * X[0], -0.7 * Y[0], -1))
        ol.end()

        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((-0.7 * X[i], -0.7 * Y[i], -1))
        ol.vertex3((-0.7 * X[0], -0.7 * Y[0], -1))
        ol.end()
Esempio n. 37
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        ol.color3(1.0, 0.0, 1.0);
        font = ol.getDefaultFont()
        s = "Lux!"
        w = ol.getStringWidth(font, 0.2, s)
        ol.drawString(font, (-w/2,0.1), 0.2, s)

        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))

        for i in range(2):

            if (i == 1):
                ol.color3(1.0,1.0,0.0);
            else:
                ol.color3(0.0,1.0,1.0);
                    
            ol.scale3((0.6, 0.6, 0.6))
            ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
            ol.rotate3X(lux.time * pi * 0.8 * lux.simple_rate)
            ol.rotate3Y(lux.time * pi * 0.73 * lux.simple_rate)
            
            ol.begin(ol.LINESTRIP)
            ol.vertex3((-1, -1, -1))
            ol.vertex3(( 1, -1, -1))
            ol.vertex3(( 1,  1, -1))
            ol.vertex3((-1,  1, -1))
            ol.vertex3((-1, -1, -1))
            ol.vertex3((-1, -1,  1))
            ol.end()

            ol.begin(ol.LINESTRIP);
            ol.vertex3(( 1,  1,  1))
            ol.vertex3((-1,  1,  1))
            ol.vertex3((-1, -1,  1))
            ol.vertex3(( 1, -1,  1))
            ol.vertex3(( 1,  1,  1))
            ol.vertex3(( 1,  1, -1))
            ol.end()

            ol.begin(ol.LINESTRIP)
            ol.vertex3(( 1, -1, -1))
            ol.vertex3(( 1, -1,  1))
            ol.end()

            ol.begin(ol.LINESTRIP)
            ol.vertex3((-1,  1,  1))
            ol.vertex3((-1,  1, -1))
            ol.end()
Esempio n. 38
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        for i in range(2):
            ol.loadIdentity3()
            ol.perspective(20, 1, 1, 100)
            ol.translate3((0, 0, -20))

            if (i == 1):
                ol.color3(1.0,1.0,0.0);
                ol.translate3((cos(lux.time/2.0), cos(lux.time/3.0), cos(lux.time/7.0)))
                ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
                ol.rotate3X(lux.time * pi * 0.25 * lux.simple_rate)
                ol.rotate3Y(lux.time * pi * 0.13 * lux.simple_rate)
            else:
                ol.color3(0.0,1.0,1.0);
                ol.scale3((0.6, 0.6, 0.6))
                ol.translate3((cos(lux.time/3.2), cos(lux.time/2.6), cos(lux.time/5.4)))
                ol.rotate3Z(lux.time * pi * 0.14 * lux.simple_rate)
                ol.rotate3X(lux.time * pi * 0.53 * lux.simple_rate)
                ol.rotate3Y(lux.time * pi * 0.22 * lux.simple_rate)
            
            ol.begin(ol.LINESTRIP)
            ol.vertex3((-1, -1, -1))
            ol.vertex3(( 1, -1, -1))
            ol.vertex3(( 1,  1, -1))
            ol.vertex3((-1,  1, -1))
            ol.vertex3((-1, -1, -1))
            ol.vertex3((-1, -1,  1))
            ol.end()

            ol.begin(ol.LINESTRIP);
            ol.vertex3(( 1,  1,  1))
            ol.vertex3((-1,  1,  1))
            ol.vertex3((-1, -1,  1))
            ol.vertex3(( 1, -1,  1))
            ol.vertex3(( 1,  1,  1))
            ol.vertex3(( 1,  1, -1))
            ol.end()

            ol.begin(ol.LINESTRIP)
            ol.vertex3(( 1, -1, -1))
            ol.vertex3(( 1, -1,  1))
            ol.end()

            ol.begin(ol.LINESTRIP)
            ol.vertex3((-1,  1,  1))
            ol.vertex3((-1,  1, -1))
            ol.end()
Esempio n. 39
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        ol.color3(1.0, 0.0, 1.0)
        font = ol.getDefaultFont()
        s = "davidad"
        x = sin(lux.time) * 0.5
        w = ol.getStringWidth(font, x, s)
        #ol.drawString(font, (-w/2,0), x, s)

        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))

        t = lux.time * 2
        lx = 0
        ly = 0
        for i in range(8):

            c = floor(t * 2 + i) % 3
            c = 3
            if (c == 1):
                #if(1):
                ol.color3(1.0, 1.0, 0.0)
            if (c == 2):
                ol.color3(0.0, 1.0, 1.0)
            if (c == 3):
                ol.color3(1.0, 0.0, 1.0)

            ol.scale3((0.6, 0.6, 0.6))
            #ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
            #ol.rotate3X(lux.time * pi * 0.8 * lux.simple_rate)
            #ol.rotate3Y(lux.time * pi * 0.73 * lux.simple_rate)

            z = 2 * sin(t * 2)
            z = -1 + 4 * (t * 2 - floor(t * 2))
            #z = 4
            x = 0.5 * sin(t + i / 1.0)
            y = 0.5 * cos(t + i / 1.0)

            ol.begin(ol.LINESTRIP)
            ol.vertex3((x - 1, y - 1, z))
            ol.vertex3((x - 1, y + 1, z))
            ol.vertex3((x + 1, y + 1, z))
            ol.vertex3((x + 1, y - 1, z))
            ol.vertex3((x - 1, y - 1, z))
            ol.end()

            if i != 0:
                ol.begin(ol.LINESTRIP)
                ol.vertex3((x - 1, y - 1, z))
                ol.vertex3((lx - 1, ly - 1, z + 4))
                ol.end()

                ol.begin(ol.LINESTRIP)
                ol.vertex3((x - 1, y + 1, z))
                ol.vertex3((lx - 1, ly + 1, z + 4))
                ol.end()

                ol.begin(ol.LINESTRIP)
                ol.vertex3((x + 1, y + 1, z))
                ol.vertex3((lx + 1, ly + 1, z + 4))
                ol.end()

                ol.begin(ol.LINESTRIP)
                ol.vertex3((x + 1, y - 1, z))
                ol.vertex3((lx + 1, ly - 1, z + 4))
                ol.end()

            lx = x
            ly = y
Esempio n. 40
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        ol.color3(1.0, 0.0, 1.0);
        font = ol.getDefaultFont()
        s = "davidad"
	x = sin(lux.time)*0.5;
        w = ol.getStringWidth(font, x, s)
        #ol.drawString(font, (-w/2,0), x, s)

        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))

        t = lux.time*2
        lx = 0
        ly = 0
        for i in range(8):

            c = floor(t*2+i)%3
            c = 3
            if (c==1):
	    #if(1):
                ol.color3(1.0,1.0,0.0);
            if (c==2):
                ol.color3(0.0,1.0,1.0);
            if (c==3):
                ol.color3(1.0,0.0,1.0);
                    
            ol.scale3((0.6, 0.6, 0.6))
            #ol.rotate3Z(lux.time * pi * 0.1 * lux.simple_rate)
            #ol.rotate3X(lux.time * pi * 0.8 * lux.simple_rate)
            #ol.rotate3Y(lux.time * pi * 0.73 * lux.simple_rate)

	    z = 2*sin(t*2)
            z = -1+4*(t*2-floor(t*2))
            #z = 4
            x = 0.5*sin(t+i/1.0);
            y = 0.5*cos(t+i/1.0);

            ol.begin(ol.LINESTRIP)
            ol.vertex3((x-1,y-1,z))
            ol.vertex3((x-1,y+1,z))
            ol.vertex3((x+1,y+1,z))
            ol.vertex3((x+1,y-1,z))
            ol.vertex3((x-1,y-1,z))
            ol.end()

            if i != 0:
                ol.begin(ol.LINESTRIP)
                ol.vertex3((x-1,y-1,z))
                ol.vertex3((lx-1,ly-1,z+4))
                ol.end()
            
                ol.begin(ol.LINESTRIP)
                ol.vertex3((x-1,y+1,z))
                ol.vertex3((lx-1,ly+1,z+4))
                ol.end()
            
                ol.begin(ol.LINESTRIP)
                ol.vertex3((x+1,y+1,z))
                ol.vertex3((lx+1,ly+1,z+4))
                ol.end()
            
                ol.begin(ol.LINESTRIP)
                ol.vertex3((x+1,y-1,z))
                ol.vertex3((lx+1,ly-1,z+4))
                ol.end()

            lx = x
            ly = y
Esempio n. 41
0
    def draw(self, audio):
        '''a square'''
        #self.x = math.cos(2*pi*rotate_frequency*lux.time + self.angle + self.base_angle) * self.distance * self.distance_scale
        #self.y = math.sin(2*pi*rotate_frequency*lux.time + self.angle + self.base_angle) * self.distance * self.distance_scale

        #stolen from guilloche
        time = lux.time * time_scale
        R = math.sin(2 * pi * self.R_frequency * time) * self.R + 0.0001
        r = math.sin(2 * pi * self.r_frequency * time) * self.r + 0.0001
        p = math.sin(2 * pi * self.p_frequency * time) * self.p + 0.0001
        self.x = (R + r) * math.cos(time) + (r + p) * math.cos(
            (R + r) / r * time)
        self.y = (R + r) * math.sin(time) + (r + p) * math.sin(
            (R + r) / r * time)

        #clamp to display area
        if clamp_display:
            if self.x > 1: self.x = 1
            if self.y > 1: self.y = 1
            if self.x < -1: self.x = -1
            if self.y < -1: self.y = -1
        self.x *= scale
        self.y *= scale
        #self.graphics.circle(0, 0, self.radius)
        ol.loadIdentity3()
        ol.loadIdentity()

        #ol.color3(self.color[0], self.color[1], self.color[2])
        ol.color3(self.red, self.green, self.blue)
        ol.translate3((self.x, self.y, 0))
        angle = math.atan2(self.y, self.x) / (2 * pi)
        red = self.red  #abs(math.sin(2*pi*(r_prime/3+ctf*time+clf*self.n+caf*angle)))*self.red
        green = abs(
            math.sin(2 * pi * (g_prime / 3 + ctf * time + clf * self.n +
                               caf * angle))) * self.green
        blue = abs(
            math.sin(2 * pi * (b_prime / 3 + ctf * time + clf * self.n +
                               caf * angle))) * self.blue
        if seizure_mode:
            #red, green, blue = red/self.radius, green/self.radius, blue/self.radius
            red = abs(red * math.tan((2 * pi * self.radius / node_big_radius)))
            green = abs(green * math.tan(
                (2 * pi * self.radius / node_big_radius)))
            blue = abs(blue * math.tan(
                (2 * pi * self.radius / node_big_radius)))
        if audio:
            try:
                #seems most of the time all the samples are empty
                #sample_index = int((self.n/max_nodes)*audio[0].shape[0])
                sample_index = 0  #self.n
                sample = audio[0][n]

            except:
                sample = 1
        else:
            sample = 1  #[0 for x in range(10000)] #empty vector
        #print sample
        if audio:
            red = red
            blue = blue + sample * self.audio_gain
            green = green + sample * self.audio_gain
        ol.color3(red, green, blue)
        if self.last_sample - sample > 0.1:
            pass  #pulse
        #do squares have radii?
        s = self.radius
        ol.begin(ol.POINTS)
        ol.vertex3((-s, s, 0))
        ol.vertex3((-s, s, 0))
        ol.vertex3((s, s, 0))
        ol.vertex3((s, -s, 0))
        ol.vertex3((-s, -s, 0))
        ol.end()
Esempio n. 42
0
    def draw(self):
        theta = arange(0,2*pi,2*pi/self.N);

        # rotations in q-space
        mu = 0.01
        std=0.001;
        
        dth1=random.gauss(mu,std);
        dth2=random.gauss(mu,std);
        dth3=random.gauss(mu,std);
        dth4=random.gauss(mu,std);
        dth5=random.gauss(mu,std);
    
        dth1b=random.gauss(mu,std);
        dth2b=random.gauss(mu,std);
        dth3b=random.gauss(mu,std);
        dth4b=random.gauss(mu,std);
        dth5b=random.gauss(mu,std);
    
        # dth1=self.dtheta*(1-2*(random.random()<self.cut));
        # dth2=self.dtheta*(1-2*(random.random()<self.cut));
        # dth3=self.dtheta*(1-2*(random.random()<self.cut));
        # dth4=self.dtheta*(1-2*(random.random()<self.cut));
        # dth5=self.dtheta*(1-2*(random.random()<self.cut));
    
        # dth1b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth2b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth3b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth4b=self.dtheta*(1-2*(random.random()<self.cut));
        # dth5b=self.dtheta*(1-2*(random.random()<self.cut));

        self.th1=self.th1+dth1;
        self.th2=self.th2+dth2;
        self.th3=self.th3+dth3;
        self.th4=self.th4+dth4;
        self.th5=self.th5+dth5;
    
        self.th1b=self.th1b+dth1b;
        self.th2b=self.th2b+dth2b;
        self.th3b=self.th3b+dth3b;
        self.th4b=self.th4b+dth4b;
        self.th5b=self.th5b+dth5b;
    
        c1=self.m1*cos(self.th1);
        s1=self.m1*sin(self.th1);
        c2=self.m2*cos(self.th2);
        s2=self.m2*sin(self.th2);
        c3=self.m3*cos(self.th3);
        s3=self.m3*sin(self.th3);
        c4=self.m4*cos(self.th4);
        s4=self.m4*sin(self.th4);
        c5=self.m5*cos(self.th5);
        s5=self.m5*sin(self.th5);
    
        X=c1*cos(theta+self.th1b)+c2*cos(2*theta+self.th2b)+c3*cos(3*theta+self.th3b)+c4*cos(4*theta+self.th4b)+c5*cos(5*theta+self.th5b);
        Y=s1*sin(theta+self.th1b)+s2*sin(2*theta+self.th2b)+s3*sin(3*theta+self.th3b)+s4*sin(4*theta+self.th4b)+s5*sin(5*theta+self.th5b);
    
        X=(X-X.mean()).astype("complex")
        Y=(Y-Y.mean()).astype("complex")

        s = arange(1,self.N+1,1)

        Xtemp=X**self.p1x * Y**self.p1y + 2*s*1j - self.N*1j;
        Ytemp=X**self.p2x * Y**self.p2y + 2*s*1j - self.N*1j;

        X=Xtemp.real
        Y=Ytemp.real

        X=tanh(2*X);
        Y=tanh(2*Y);

        ol.loadIdentity3()
        ol.loadIdentity()
        ol.color3(*(self.color_cycle()))

        render_type = ol.POINTS

        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((X[i], Y[i], -1))
        ol.vertex3((X[0], Y[0], -1))
        ol.end()
        
        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((-X[i], Y[i], -1))
        ol.vertex3((-X[0], Y[0], -1))
        ol.end()

        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((0.7*X[i], -0.7*Y[i], -1))
        ol.vertex3((0.7*X[0], -0.7*Y[0], -1))
        ol.end()
        
        ol.begin(ol.POINTS)
        for i in range(X.shape[0]):
            ol.vertex3((-0.7*X[i], -0.7*Y[i], -1))
        ol.vertex3((-0.7*X[0], -0.7*Y[0], -1))
        ol.end()
Esempio n. 43
0
 def draw(self):
     if self.lines_only:
         ol.begin(ol.LINESTRIP)
         x, y =  self.segments[0].start
         ol.vertex3((x, y, 0), self.color)
         for i in self.segments:
             ol.vertex3((i.end[0], i.end[1], 0), self.color)
         ol.end()
     else:
         ol.begin(ol.BEZIERSTRIP)
         x, y = self.segments[0].start
         ol.vertex3((x, y, 0), self.color)
         for i in self.segments:
             i = i.to_bezier4()
             ol.vertex3((i.cp1[0], i.cp1[1], 0), self.color)
             ol.vertex3((i.cp2[0], i.cp2[1], 0), self.color)
             ol.vertex3((i.end[0], i.end[1], 0), self.color)
         ol.end()
Esempio n. 44
0
    def draw(self):
        time = lux.time
        #time = self.time
        ctf = self.color_time_frequency
        clf = self.color_length_frequency
        caf = self.color_angle_frequency / 2
        theta = abs(math.sin(time * self.time_scale))
        R = self.R * math.sin(
            2 * pi * time * self.time_scale * self.R_frequency)
        r = self.r * math.sin(
            2 * pi * time * self.time_scale * self.r_frequency)
        p = self.p * math.sin(
            2 * pi * time * self.time_scale * self.p_frequency) * self.bass
        audio = self.get_audio()

        ol.color3(1.0, 0.0, 1.0)
        ol.loadIdentity3()
        ol.loadIdentity()
        ol.perspective(60, 1, 1, 100)
        ol.translate3((0, 0, -3))

        first = True
        n = 0
        while theta < 2 * pi * self.max_cycles and n < self.max_segments:
            theta += self.theta_step
            if audio:
                try:
                    sample_index = int(
                        theta / (2 * pi * self.max_cycles) *
                        (audio[0].shape[0] - 1)) + 1  #skip first sample
                    sample = audio[2][sample_index]
                except:
                    sample = 0
            else:
                sample = 0  #[0 for x in range(10000)] #empty vector
            #x = (R + r) * math.cos(theta)
            #y = (R + r) * math.sin(theta)
            sample *= self.audio_gain
            #print sample
            #x = (R + r) * math.cos(theta) + (r + p + sample) * math.cos((R+r)/r * theta)
            #y = (R + r) * math.sin(theta) + (r + p + sample) * math.sin((R+r)/r * theta)
            #ben's ill advised DALT change
            x = (R + r) * math.cos(theta) + (r + p * sample) * math.cos(
                (R + r) / r * theta)
            y = (R + r) * math.sin(theta) + (r + p * sample) * math.sin(
                (R + r) / r * theta)

            if first:
                #ol.begin(ol.LINESTRIP)
                ol.begin(ol.POINTS)
                first = False
            #red = math.sin(ctf*time*n/37) * math.sin(csf*theta*n/37)
            #green = math.sin(ctf*time*n/23) * math.sin(csf*theta*n/23)
            #blue = math.sin(ctf*time*n/128) * math.sin(csf*theta*n/128)

            angle = math.atan2(y, x) / (2 * pi)
            red = abs(
                math.sin(
                    2 * pi *
                    (self.r_prime / 3 + ctf * time + clf * n + caf * angle)))
            green = abs(
                math.sin(
                    2 * pi *
                    (self.g_prime / 3 + ctf * time + clf * n + caf * angle)))
            blue = abs(
                math.sin(
                    2 * pi *
                    (self.b_prime / 3 + ctf * time + clf * n + caf * angle)))
            ol.color3(red, green, blue)

            #this makes it square-ish
            #x += math.cos(2*pi*angle*self.spatial_resonance)*self.spatial_resonance_amplitude
            #y += math.sin(2*pi*angle*self.spatial_resonance)*self.spatial_resonance_amplitude
            x += math.cos(2 * pi * angle * (self.spatial_resonance + 1) +
                          2 * pi * self.spatial_resonance_offset
                          ) * self.spatial_resonance_amplitude
            y += math.sin(2 * pi * angle * (self.spatial_resonance + 1) +
                          2 * pi * self.spatial_resonance_offset
                          ) * self.spatial_resonance_amplitude

            x *= self.width
            y *= self.height
            ol.vertex3((x, y, 0))
            n += 1
        ol.end()
        #dynamically adjust resolution
        target = self.max_segments * 0.8
        error = (target - n) / target
        self.theta_step = min(max(1e-100, self.theta_step * (1 - error)), 1)
        #print n,  angle
        self.time += 1 / 30
Esempio n. 45
0
	ol.perspective(60, 1, 1, 100)
	ol.translate3((0, 0, -3))

	for i in range(2):
		if (i == 1):
                    ol.color3(1.0,0.0,0.0);
                else:
                    ol.color3(0.0,1.0,0.0);

		ol.scale3((0.6, 0.6, 0.6))
		ol.rotate3Z(time * pi * 0.1)
		ol.rotate3X(time * pi * 0.8)
		ol.rotate3Y(time * pi * 0.73)

		ol.begin(ol.LINESTRIP)
		ol.vertex3((-1, -1, -1))
		ol.vertex3(( 1, -1, -1))
		ol.vertex3(( 1,  1, -1))
		ol.vertex3((-1,  1, -1))
		ol.vertex3((-1, -1, -1))
		ol.vertex3((-1, -1,  1))
		ol.end()

		ol.begin(ol.LINESTRIP);
		ol.vertex3(( 1,  1,  1))
		ol.vertex3((-1,  1,  1))
		ol.vertex3((-1, -1,  1))
		ol.vertex3(( 1, -1,  1))
		ol.vertex3(( 1,  1,  1))
		ol.vertex3(( 1,  1, -1))
		ol.end()
Esempio n. 46
0
    font = ol.getDefaultFont()
    s = "Hi!"
    w = ol.getStringWidth(font, 0.2, s)
    ol.drawString(font, (-w / 2, 0.1), 0.2, ol.C_WHITE, s)

    ol.perspective(60, 1, 1, 100)
    ol.translate3((0, 0, -3))

    for i in range(2):
        ol.scale3((0.6, 0.6, 0.6))
        ol.rotate3Z(time * pi * 0.1)
        ol.rotate3X(time * pi * 0.8)
        ol.rotate3Y(time * pi * 0.73)

        ol.begin(ol.LINESTRIP)
        ol.vertex3((-1, -1, -1), ol.C_WHITE)
        ol.vertex3((1, -1, -1), ol.C_WHITE)
        ol.vertex3((1, 1, -1), ol.C_WHITE)
        ol.vertex3((-1, 1, -1), ol.C_WHITE)
        ol.vertex3((-1, -1, -1), ol.C_WHITE)
        ol.vertex3((-1, -1, 1), ol.C_WHITE)
        ol.end()

        ol.begin(ol.LINESTRIP)
        ol.vertex3((1, 1, 1), ol.C_WHITE)
        ol.vertex3((-1, 1, 1), ol.C_WHITE)
        ol.vertex3((-1, -1, 1), ol.C_WHITE)
        ol.vertex3((1, -1, 1), ol.C_WHITE)
        ol.vertex3((1, 1, 1), ol.C_WHITE)
        ol.vertex3((1, 1, -1), ol.C_WHITE)
        ol.end()
Esempio n. 47
0
    def draw(self):
   
        self.i=self.i+1.0;
        
        #inverse persistence length
        self.thetad=0.25*(1.0+sin(2.0*pi*self.i/2000.0))
    
        #RGB curliness offset
        offset=pi/6.0
    
        #RGB curly-straight cycle frequency
        crlstrt=0.005
    
        #RGB maximum curlyness
        curlmx=0.2
    
        theta0B=curlmx*cos(self.i*crlstrt)
        theta0R=curlmx*cos(self.i*crlstrt+offset)
        theta0G=curlmx*cos(self.i*crlstrt+2.0*offset)
    
        self.thetaB=self.thetaB+random.gauss(theta0B,self.thetad)
        self.thetaR=self.thetaR+random.gauss(theta0R,self.thetad)
        self.thetaG=self.thetaG+random.gauss(theta0G,self.thetad)
    
        self.BX=np.append(self.BX[1:], self.BX[-1]+self.dr*cos(self.thetaB))
        self.BY=np.append(self.BY[1:], self.BY[-1]+self.dr*sin(self.thetaB))
        
        self.RX=np.append(self.RX[1:], self.RX[-1]+self.dr*cos(self.thetaR))
        self.RY=np.append(self.RY[1:], self.RY[-1]+self.dr*sin(self.thetaR))
    
        self.GX=np.append(self.GX[1:], self.GX[-1]+self.dr*cos(self.thetaG))
        self.GY=np.append(self.GY[1:], self.GY[-1]+self.dr*sin(self.thetaG))
         
        # derivative roughness parameter
        # b=0.1;
        # if b != 0.0:
        #     [Fx,Fy]=gradient([self.BX;self.RX;self.GX;self.BY;self.RY;self.GY])
        
        #     self.BX=b*Fx(4,:)+self.BX
        #     self.RX=b*Fx(5,:)+self.RX
        #     self.GX=b*Fx(6,:)+self.GX
        
        #     self.BY=b*Fx(1,:)+self.BY
        #     self.RY=b*Fx(2,:)+self.RY
        #     self.GY=b*Fx(3,:)+self.GY
    
        #combine paths
        rmult=0.0001;
        if 1:
            fmB=0.5
            fmG=0.5
        
            #            self.BX=(self.BX+self.RX+(2*random.uniform(1,self.N)-1.0)*rmult)/2.0
            self.BX=(self.BX+self.RX)/2.0
            self.BY=(self.BY+self.RY+(2*random.uniform(1,self.N)-1.0)*rmult)/2.0
        
            self.RX=(self.RX+self.GX+(2*random.uniform(1,self.N)-1.0)*rmult)/2.0
            self.RY=(self.RY+self.GY+(2*random.uniform(1,self.N)-1.0)*rmult)/2.0
        
            self.GX=(self.BX+self.GX+(2*random.uniform(1,self.N)-1.0)*rmult)/2.0
            self.GY=(self.BY+self.GY+(2*random.uniform(1,self.N)-1.0)*rmult)/2.0
        else:
            fmB=1.0
            fmG=1.0
    
        #spin frequency
        freq=0.01+random.gauss(0,0.002)
    
        self.BX=cos(freq*fmB)*self.BX-sin(freq*fmB)*self.BY
        self.BY=sin(freq*fmB)*self.BX+cos(freq*fmB)*self.BY
    
        self.RX=cos(freq)*self.RX-sin(freq)*self.RY
        self.RY=sin(freq)*self.RX+cos(freq)*self.RY
        
        self.GX=cos(freq*fmG)*self.GX-sin(freq*fmG)*self.GY
        self.GY=sin(freq*fmG)*self.GX+cos(freq*fmG)*self.GY
    
        #centering
        self.BX=self.BX-self.BX.mean()
        self.BY=self.BY-self.BY.mean()
    
        self.RX=self.RX-self.RX.mean()
        self.RY=self.RY-self.RY.mean()
    
        self.GX=self.GX-self.GX.mean()
        self.GY=self.GY-self.GY.mean()
    
        #scaling and bouncy factor
        bounce=5.0
        self.fB  =  self.fB + ((self.fB+max(np.sqrt(self.BX**2+self.BY**2)))/2.0-self.fB)/bounce
        self.fR  =  self.fR + ((self.fR+max(np.sqrt(self.RX**2+self.RY**2)))/2.0-self.fR)/bounce
        self.fG  =  self.fG + ((self.fG+max(np.sqrt(self.GX**2+self.GY**2)))/2.0-self.fG)/bounce
    
        self.BX=self.BX/self.fB
        self.BY=self.BY/self.fB
    
        self.RX=self.RX/self.fR
        self.RY=self.RY/self.fR
        
        self.GX=self.GX/self.fG
        self.GY=self.GY/self.fG    
    
        ####################################
        #LUX RENDERING CODE
        ####################################

        ol.loadIdentity3()
        ol.loadIdentity()
        #        ol.color3(*(self.color_cycle()))
        ol.scale3((self.scale_factor,self.scale_factor,self.scale_factor))
        theta_rot = 0.4*cos(1.7 * lux.time * self.ROT_RATE) + 0.6*cos(0.7 * lux.time * self.ROT_RATE)
        ol.rotate3Z(theta_rot)


        render_type  =  ol.POINTS

        current_hue_marker = self.writhe_current_hue
        current_hue_target = self.writhe_hue_target
        current_hue_step = self.writhe_hue_step
        
#        ol.color3(0.0,0.0,1.0)
        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((self.BX[i], self.BY[i], -1))
        ol.end()

        self.writhe_current_hue = current_hue_marker
        self.writhe_current_target = current_hue_target
        self.writhe_current_step = current_hue_step

        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((-self.BX[i], self.BY[i], -1))
        ol.end()

        self.writhe_current_hue = current_hue_marker
        self.writhe_current_target = current_hue_target
        self.writhe_current_step = current_hue_step

        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((self.BX[i], -self.BY[i], -1))
        ol.end()

        self.writhe_current_hue = current_hue_marker
        self.writhe_current_target = current_hue_target
        self.writhe_current_step = current_hue_step

        ol.begin(ol.POINTS)
        for i in range(self.BX.shape[0]):
            ol.color3(*(self.writhe_color_cycle()))
            ol.vertex3((-self.BX[i], -self.BY[i], -1))
        ol.end()
Esempio n. 48
0
    def draw(self):
        self.tweener.add_tween(self, scale_factor=0.25, time_scale = 1.0, duration=0.1, \
                               easing=pytweener.Easing.Expo.ease_in_out)

        ol.loadIdentity()
        ol.loadIdentity3()
        ol.translate3((-0.1, 0.0, 0.0))
        ol.scale3((self.scale_factor, self.scale_factor, self.scale_factor))

        # Spawn photons randomly
        if len(self.photons) < MAX_PHOTONS and random.random(
        ) < SPAWN_THRESHOLD:
            p = Photon()
            self.photons.append(p)

        # Draw photons
        dt = self.time_scale * (lux.time - self.last_time)
        self.last_time = lux.time
        self.tweener.update(lux.time - self.last_time)

        for p in self.photons:
            p.update(dt, self.photon_speed)
            p.draw()

        ol.color3(1.0, 1.0, 1.0)
        font = ol.getDefaultFont()
        s = "LASER"
        w = ol.getStringWidth(font, 1.0, s)
        ol.drawString(font, (-w / 2, 1.1), 1.0, s)

        # Draw the bounding box, with a very small hole in it.
        ol.color3(0.0, 1.0, 0.0)
        ol.begin(ol.LINESTRIP)
        ol.vertex3((CAVITY_SIZE[0] / 2, 0.1, 0.0))
        ol.vertex3((CAVITY_SIZE[0] / 2, CAVITY_SIZE[1] / 2, 0.0))
        ol.vertex3((-CAVITY_SIZE[0] / 2, CAVITY_SIZE[1] / 2, 0.0))
        ol.vertex3((-CAVITY_SIZE[0] / 2, -CAVITY_SIZE[1] / 2, 0.0))
        ol.vertex3((CAVITY_SIZE[0] / 2, -CAVITY_SIZE[1] / 2, 0.0))
        ol.vertex3((CAVITY_SIZE[0] / 2, -0.1, 0.0))
        ol.end()
Esempio n. 49
0
    def draw(self):
        self.tweener.add_tween(self, scale_factor=0.25, time_scale = 1.0, duration=0.1, \
                               easing=pytweener.Easing.Expo.ease_in_out)

        
        ol.loadIdentity()
        ol.loadIdentity3()
        ol.translate3((-0.1, 0.0, 0.0))
        ol.scale3((self.scale_factor, self.scale_factor, self.scale_factor))

        # Spawn photons randomly
        if len(self.photons) < MAX_PHOTONS and random.random() < SPAWN_THRESHOLD:
            p = Photon();
            self.photons.append(p)

        # Draw photons
        dt = self.time_scale * (lux.time - self.last_time)
        self.last_time = lux.time
        self.tweener.update(lux.time - self.last_time)
        
        for p in self.photons:
            p.update(dt, self.photon_speed)
            p.draw()

        ol.color3(1.0, 1.0, 1.0);
        font = ol.getDefaultFont()
        s = "LASER"
        w = ol.getStringWidth(font, 1.0, s)
        ol.drawString(font, (-w/2,1.1), 1.0, s)

        # Draw the bounding box, with a very small hole in it.
        ol.color3(0.0, 1.0, 0.0);
        ol.begin(ol.LINESTRIP)
        ol.vertex3(( CAVITY_SIZE[0]/2,  0.1, 0.0))
        ol.vertex3(( CAVITY_SIZE[0]/2,  CAVITY_SIZE[1]/2, 0.0))
        ol.vertex3((-CAVITY_SIZE[0]/2,  CAVITY_SIZE[1]/2, 0.0))
        ol.vertex3((-CAVITY_SIZE[0]/2, -CAVITY_SIZE[1]/2, 0.0))
        ol.vertex3(( CAVITY_SIZE[0]/2, -CAVITY_SIZE[1]/2, 0.0))
        ol.vertex3(( CAVITY_SIZE[0]/2,  -0.1, 0.0))
        ol.end()
Esempio n. 50
0
    def draw(self):
        ol.loadIdentity3()
        ol.loadIdentity()

        for i in range(2):
            ol.loadIdentity3()
            ol.perspective(20, 1, 1, 100)
            ol.translate3((0, 0, -20))

            if (i == 1):
                ol.color3(1.0, 1.0, 0.0)
                ol.translate3((cos(lux.time / 2.0), cos(lux.time / 3.0),
                               cos(lux.time / 7.0)))
                ol.rotate3Z(lux.time * pi * 0.1 * lux.TwoCubes_simple_rate)
                ol.rotate3X(lux.time * pi * 0.25 * lux.TwoCubes_simple_rate)
                ol.rotate3Y(lux.time * pi * 0.13 * lux.TwoCubes_simple_rate)
            else:
                ol.color3(0.0, 1.0, 1.0)
                ol.scale3((0.6, 0.6, 0.6))
                ol.translate3((cos(lux.time / 3.2), cos(lux.time / 2.6),
                               cos(lux.time / 5.4)))
                ol.rotate3Z(lux.time * pi * 0.14 * lux.TwoCubes_simple_rate)
                ol.rotate3X(lux.time * pi * 0.53 * lux.TwoCubes_simple_rate)
                ol.rotate3Y(lux.time * pi * 0.22 * lux.TwoCubes_simple_rate)

            ol.begin(ol.LINESTRIP)
            ol.vertex3((-1, -1, -1))
            ol.vertex3((1, -1, -1))
            ol.vertex3((1, 1, -1))
            ol.vertex3((-1, 1, -1))
            ol.vertex3((-1, -1, -1))
            ol.vertex3((-1, -1, 1))
            ol.end()

            ol.begin(ol.LINESTRIP)
            ol.vertex3((1, 1, 1))
            ol.vertex3((-1, 1, 1))
            ol.vertex3((-1, -1, 1))
            ol.vertex3((1, -1, 1))
            ol.vertex3((1, 1, 1))
            ol.vertex3((1, 1, -1))
            ol.end()

            ol.begin(ol.LINESTRIP)
            ol.vertex3((1, -1, -1))
            ol.vertex3((1, -1, 1))
            ol.end()

            ol.begin(ol.LINESTRIP)
            ol.vertex3((-1, 1, 1))
            ol.vertex3((-1, 1, -1))
            ol.end()