 |
| Fuzzycraft - not minecraft! |
Flocking is one of those things I've been meaning to play with for a while. So here is my crude result; flocking in javascript. I'm not quite sure what type of flock it's simulating... definitely not birds though. I'm calling them noids.
$ easy_install mark3 $ python -m mark3 < myfile.textOr used as a python module:
from mark3.markdown import markdown html_output = markdown(raw_text)I wanted a markdown to html converter for python3 that was lightweight and fast. So I created mark3.
$ hg clone https://bitbucket.org/jlm/mark3 $ cd mark3 $ python tests/speed_test.pySee the README for details on how mark3 differs from the official markdown implementation.
var dt = new Date().getTime() - last_time;Still use setInterval for scheduling logic and render functions, just don't expect the timeout values to be consistent with actual times.
var buffer = document.createElement('canvas');
var buffer_ctx = buffer.getContext('2d');
// ... draw to buffer_ctx ...Then simply use our new buffer as an image:main_ctx.drawImage(buffer, 0, 0);For example, I can use an off-screen buffer to apply an expensive bloom effect:
I recently started supporting Number Drill, my math drill software, for Linux a few days ago. Number Drill is a pure python program with the external dependencies of pygame, rabbyt, PyOpenGL and a few others. All of which were in the Debian and Fedora repositories.
I originally tried using cx_Freeze to make a binary to distribute. But I kept on running into major problems with this method. And as it ended up I would have to include a plethora of .so files (such as all of pygame and everything that it depends on, libssl and everything it depends on etc) just to avoid version conflicts that resulted in segfaults. Not to mention the resulting package ending up far larger than it should be.
That was about the time Matthew suggested just distributing the pyc files (gasp! I know, it's not open source) and letting package systems like deb and rpm handle dependencies. This method has ended up working almost perfectly. Both Ubuntu 9.04 and Fedora 11 have all the dependencies I require available. The resulting packages are very small (no binaries included, just the python byte code).
The only disadvantage is that it requires the latest versions of Ubuntu or Fedora (as of today) as they are the only releases that have new enough versions of my dependencies.
We wrote a bash script that automatically packages up a pure python program into both a deb and rpm. If you are interested in here it is: http://arcticpaint.com/static/blog/python_to_deb_rpm.sh
I believe that this method of packaging is even more effective in the open source world. It essentially just makes getting your program to run from source as easy as possible.
One of the major hindrances to using PyOpenGL before 3.0 was released (not python 3.0) was that packaging it with py2exe was next to impossible. Thankfully with the release of PyOpenGL 3.0 it is easy. Just include these two imports in one of your project files:
from ctypes import util
try:
from OpenGL.platform import win32
except AttributeError:
pass
That will tell py2exe which part of PyOpenGL to include. Otherwise you have to copy them over manually. Be sure to have the try and except around all win32 imports so your program remains cross platform.
from __future__ import division
import pygame, rabbyt, sys, os
from rabbyt._rabbyt import load_texture
def next_pow2( n ):
"""
Find the next power of two.
"""
n -= 1
n = n | (n >> 1)
n = n | (n >> 2)
n = n | (n >> 4)
n = n | (n >> 8)
n = n | (n >> 16)
n += 1
return n
class Tex:
def __init__(self):
self.id = 0
self.width = 0
self.height = 0
self.tex_coords = (0,0,0,0)
_texture_cache = {}
def load_and_size(filename, filter=True, mipmap=True):
if filename not in _texture_cache:
pygame = __import__("pygame", {},{},[])
if os.path.exists(filename):
img = pygame.image.load(filename)
else:
img = pygame.image.load(os.path.join(data_directory, filename))
t = Tex()
t.width,t.height = size = list(img.get_size())
size[0] = next_pow2(size[0])
size[1] = next_pow2(size[1])
t.tex_coords = (0,t.height/size[1],t.width/size[0],0)
n = pygame.Surface(size, pygame.SRCALPHA|pygame.HWSURFACE, img)
n.blit(img, (0,size[1]-t.height))
data = pygame.image.tostring(n, 'RGBA', True)
t.id = load_texture(data, size, "RGBA", filter, mipmap)
_texture_cache[filename] = t
return _texture_cache[filename]
rabbyt.set_load_texture_file_hook(load_and_size)
