MusicPlayer.py

@@ -0,0 +1,172 @@
+import bge
+import os
+import aud
+import random
+import glob
+from DList import DoubleList
+from collections import OrderedDict
+from tinytag import TinyTag
+
+""" This is the Music Player as a component """
+class MusicPlayer(bge.types.KX_PythonComponent):
+
+    args = OrderedDict([])    
+
+    def start(self, args):
+        # dictionary
+        self.dictionary = bge.logic.globalDict
+        
+        # get mp3 files from the disk and create a list
+        self.directory = bge.logic.expandPath('//Music')
+        file_name = self.directory + '\\*.mp3'
+        file_list =  glob.glob(file_name)
+        
+        # use the mp3 list to make a playlist of nodes
+        self.playlist = DoubleList()
+        for name in file_list:
+            self.playlist.append(name)
+        
+        # previously played list of nodes
+        self.alreadyPlayed = DoubleList()
+        
+        # get a random song from the playlist, 
+        # remove it from the playlist
+        # add it to the alreadyPlayed list
+        # NOTICE: currentNode is a reference to a NODE in a list, if you want to play the song inside the node, use .data
+        self.currentNode = self.playlist.get(random.randint(0, self.playlist.getLength()))
+        self.nowPlaying = self.currentNode.getData()
+        self.playlist.remove(self.currentNode)
+        self.alreadyPlayed.append(self.nowPlaying)
+        print("Now Playing: " + self.nowPlaying)
+        self.setTag()
+        self.isPlaying = False
+
+        # create audio devices
+        self.device = aud.device()
+        self.factory = aud.Factory(self.nowPlaying)
+        self.handle = None        
+    
+    """ Update is called once every frame, and this is where
+        any input handling should go
+        
+        Controller Buttons: 
+        Y-Button - Play/Pause
+        LB       - Previous Track
+        RB       - Next Track
+        
+        TODO: Keyboard Buttons if these aren't alright
+        P        - Play/Pause
+        Pad Plus - Next Track
+        Pad Minus- Prev Track
+    """
+    def update(self):
+        keyboard = bge.logic.keyboard.events
+        up_dict = bge.logic.globalDict
+        #print(dictionary)
+        pKey = keyboard[bge.events.PKEY]
+        pPlus = keyboard[bge.events.PADPLUSKEY]
+        pMinus = keyboard[bge.events.PADMINUS]
+        lb = up_dict['lBump']
+        last_lb = up_dict['last_lBump']
+        rb = up_dict['rBump']
+        last_rb = up_dict['last_rBump']
+        y = up_dict['yBut']
+        last_y = up_dict['last_yBut']
+        JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
+        
+
+        #Run player on startup
+        if up_dict['music_start'] == True:
+            if self.isPlaying:
+                self.stopMusic()
+            else:
+                self.playMusic()                 
+            up_dict['music_start'] = False               
+
+        # Music controls only during pause/replay
+        if (up_dict['npause'] == True or up_dict['playback'] == True) or up_dict['music_start'] == True:
+            #stop/play
+            if (y == False and last_y == True) or pKey == JUST_ACTIVATED:
+                if self.isPlaying:
+                    self.stopMusic()
+                    up_dict['music_player'] = 0
+                else:
+                    self.playMusic()
+                    up_dict['music_player'] = 1
+            # Prev/Next
+            if self.isPlaying and self.handle.status:
+                if pMinus == JUST_ACTIVATED or (lb == False and last_lb == True):
+                    self.prevSong()
+                
+                if pPlus == JUST_ACTIVATED or (rb == False and last_rb == True):
+                    self.nextSong()
+        # if song ends, play next song
+        if self.isPlaying and not self.handle.status:
+            self.nextSong()
+
+    """ get info about song using TinyTag, then print to console """
+    def setTag(self):                
+        self.currTrackPath = os.path.join(self.directory, self.nowPlaying)
+        tag = TinyTag.get(self.currTrackPath)
+        self.currArtist = tag.artist
+        self.currTrackTitle = tag.title
+        self.dictionary['mu_artist'] = self.currArtist
+        self.dictionary['mu_title'] = self.currTrackTitle
+                
+        print('Artist: %s' % self.currArtist, 
+                ' Track: %s' % self.currTrackTitle)
+
+    def playMusic(self):
+        print('Play Music')
+        self.setTag()
+        self.handle = self.device.play(self.factory)
+        self.isPlaying = True
+        
+    def stopMusic(self):
+        print('Stop Music')
+        self.handle.stop()
+        self.isPlaying = False
+        
+    def nextSong(self):
+        print('Next Song')
+        # stop the current song
+        self.handle.stop()
+        
+        # get a song from the playlist
+        self.currentNode = self.playlist.get(random.randint(0, self.playlist.getLength()))
+        self.nowPlaying = self.currentNode.getData()
+        self.playlist.remove(self.currentNode)
+                
+        # add the song to the already played list
+        self.alreadyPlayed.append(self.nowPlaying)  
+        
+        # start the song
+        self.factory = aud.Factory(self.nowPlaying)
+        self.handle = self.device.play(self.factory)
+        self.setTag()
+        
+        # If playlist is empty, re-fill it
+        if self.playlist.getLength() == 0:
+            file_name = self.directory + '\\*.mp3'
+            file_list =  glob.glob(file_name)
+            for name in file_list:
+                self.playlist.append(name)
+        
+    """ Note on first call of this method, the current node will be equal to the tail of the already played list, 
+        however, it will be a node from a different list. We need to set current node equal to the tail node
+        of the already played list so that we can iterate through that list, instead of the other list """
+    def prevSong(self):
+        print('Prev Song')
+        # stop the current song
+        self.handle.stop()        
+        
+        if self.currentNode.getData() == self.alreadyPlayed.getTail().getData():
+            self.currentNode = self.alreadyPlayed.getTail()
+            
+        self.currentNode = self.currentNode.getPrev()
+        self.nowPlaying = self.currentNode.getData()
+        
+        # start the song
+        self.factory = aud.Factory(self.nowPlaying)
+        self.handle = self.device.play(self.factory)
+        self.setTag()

active_camera_loc.py

@@ -0,0 +1,12 @@
+import bge
+
+
+def set(cont):
+    own = cont.owner
+
+    #own.getWorldPosition
+    scene = bge.logic.getCurrentScene()
+    cam = scene.active_camera
+    own.worldPosition = cam.worldPosition
+
+# dont call main(bge.logic.getCurrentController()), the py controller will

curves.osl

@@ -0,0 +1,19 @@
+
+
+uniform sampler2D bgl_RenderedTexture;
+
+uniform float BC_BRIGHTNESS = 2;
+uniform float BC_CONTRAST = 1;
+
+//const float BC_CONTRAST = 1.3;    //1 is no contrast.
+//const float BC_BRIGHTNESS = 1.15;    //1 is no brightness 1.15 is good
+
+void main()
+{
+    vec4 color = texture2D(bgl_RenderedTexture, gl_TexCoord[0].st);
+    
+    color = ((color-1)*max(BC_CONTRAST,0));
+    color = color+BC_BRIGHTNESS;
+     
+    gl_FragColor = color; 
+}

lensflare01.osl

@@ -0,0 +1,72 @@
+
+uniform sampler2D bgl_RenderedTexture;
+uniform float bgl_RenderedTextureWidth;
+uniform float bgl_RenderedTextureHeight;
+uniform float sunX;
+uniform float sunY;
+uniform float timer;
+uniform float sundirect;
+uniform float sunScale; 
+
+float noise( float n )
+{
+     return fract(sin(n+timer/2.0));
+}
+
+//float noise2(vec2 co){
+    //return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+//}
+
+vec3 lensflare(vec2 uv,vec2 pos,float sunscale)
+{
+	vec2 main = uv-pos;
+	vec2 uvd = uv*(length(uv));
+	
+	float ang = atan(main.y, main.x);
+	float dist=length(main); dist = pow(dist,.1);
+	float n = noise1(vec2((ang-timer/9.0)*16.0,dist*32.0));
+	
+	float f0 = 1.0/(length(uv-pos)/sunscale+1.0);
+	
+	f0 = f0+f0*(sin((ang+timer/18.0 + noise1(abs(ang)+n/2.0)*2.0)*12.0)*.1+dist*.1+.8);
+
+	float f2 = max(1.0/(1.0+32.0*pow(length(uvd+0.8*pos),2.0)),.0)*00.25;
+	float f22 = max(1.0/(1.0+32.0*pow(length(uvd+0.85*pos),2.0)),.0)*00.23;
+	float f23 = max(1.0/(1.0+32.0*pow(length(uvd+0.9*pos),2.0)),.0)*00.21;
+	
+	vec2 uvx = mix(uv,uvd,-0.5);
+	
+	float f4 = max(0.01-pow(length(uvx+0.4*pos),2.4),.0)*6.0;
+	float f42 = max(0.01-pow(length(uvx+0.45*pos),2.4),.0)*5.0;
+	float f43 = max(0.01-pow(length(uvx+0.5*pos),2.4),.0)*3.0;
+	
+	uvx = mix(uv,uvd,-.4);
+	
+	float f5 = max(0.01-pow(length(uvx+0.2*pos),5.5),.0)*2.0;
+	float f52 = max(0.01-pow(length(uvx+0.4*pos),5.5),.0)*2.0;
+	float f53 = max(0.01-pow(length(uvx+0.6*pos),5.5),.0)*2.0;
+	
+	uvx = mix(uv,uvd,-0.5);
+	
+	float f6 = max(0.01-pow(length(uvx-0.3*pos),1.6),.0)*6.0;
+	float f62 = max(0.01-pow(length(uvx-0.325*pos),1.6),.0)*3.0;
+	float f63 = max(0.01-pow(length(uvx-0.35*pos),1.6),.0)*5.0;
+	
+	vec3 c = vec3(.0);
+	
+	c.r+=f2+f4+f5+f6; c.g+=f22+f42+f52+f62; c.b+=f23+f43+f53+f63;
+	c+=vec3(f0);
+	
+	return c;
+}
+
+void main()
+{
+    vec4 renderedTex = texture2D(bgl_RenderedTexture, gl_TexCoord[0].st);
+    float xconv = bgl_RenderedTextureWidth / bgl_RenderedTextureHeight;
+    vec2 sunPos = vec2((sunX - 0.5) * xconv, sunY - 0.5);
+    vec2 uv = vec2((gl_TexCoord[0].s - 0.5) * xconv, gl_TexCoord[0].t - 0.5);
+    vec3 lens = lensflare(uv, sunPos, sunScale);
+    renderedTex.rgb += lens * sundirect;
+    gl_FragColor = renderedTex;
+}