OpenGL wiki

http://www.opengl.org/wiki/Main_Page

IPv6 test

http://whatismyv6.com/

Open source imageworks

Pystring is a collection of C++ functions which match the interface and behavior of python's string class methods using std::string. Implemented in C++, it does not require or make use of a python interpreter. It provides convenience and familiarity for common string operations not included in the standard C++ library. It's also useful in environments where both C++ and python are used.

http://code.google.com/p/pystring/

Scala Migrations is a library to manage upgrades and rollbacks to database schemas. Migrations allow a source control system to manage together the database schema and the code using the schema. It is designed to allow multiple developers working on a project with a database backend to design schema modifications independently, apply the migrations to their local database for debugging and when complete, check them into a source control system to manage as one manages normal source code. Other developers then check out the new migrations and apply them to their local database. Finally, the migrations are used to migrate the production databases to the latest schema version.

The package is based off Ruby on Rails Migrations and in fact shares the exact same schema_migrations table to manage the list of installed migrations. The Scala Migrations library is written in Scala and makes use of the clean Scala language to write easy to understand migrations, which are also written in Scala. Scala Migrations provides a database abstraction layer that allows migrations to target any supported database vendor.

http://code.google.com/p/scala-migrations/

ilog license manager

ilog ILM Error 4: Views: cannot connect to token server

[-@- ilm]$ su -

[root@- ~]# cd /usr/ilog/

[root@- /usr/ilog]# cd ilm

[root@- /usr/ilog/ilm]# ./ilmd &

[root@- /usr/ilog/ilm]# Jan 18 22:12:22 UTC 0 ILOG License Manager v2.7.0 (rev. 'r').

Jan 18 22:12:22 UTC 8 Running on linux [pid 19655]

Jan 18 22:12:24 UTC V Using license file "/usr/ilog/ilm/access.ilm"

Jan 18 22:12:26 UTC o TOKEN reservation period = 0 sec

Jan 18 22:12:28 UTC D Licensed to ""

Jan 18 22:12:30 UTC G Tokens for Scheduler on -: 1 linux 

Jan 18 22:12:30 UTC T Tokens for Solver on -: 1 linux 

Jan 18 22:12:30 UTC 7 Tokens for Views: 2 linux , server: - , license: -

Jan 18 22:12:32 UTC x * Warning! Views was used by -, pid 5353, usage=

OpenGL text display using FTGL
Making the demo work on Ubuntu

tohare@quantum-solace:~/projects/ftgl-demo$ cat Makefile
FTGL_CPPFLAGS := $(shell pkg-config --cflags ftgl)
FTGL_LDFLAGS := $(shell pkg-config --libs-only-L ftgl)
FTGL_LIBS := $(shell pkg-config --libs-only-l ftgl)
OBJDIR := obj

CXX := g++
CXXFLAGS := -MMD -g -Wall -Wextra -Wno-unused-parameter -march=pentium4 -O2 $(FTGL_CPPFLAGS)

#INCLUDE :=
LDFLAGS := $(FTGL_LDFLAGS)
LDLIBS := $(FTGL_LIBS) -lglut

SRCScc := demo.cc
OBJS = $(patsubst %.cc,$(OBJDIR)/%.o,$(SRCScc))

# PHONY is used when the target is not a file
.PHONY: all clean

all: demo

demo: $(OBJS)
$(CXX) $(LDFLAGS) $^ $(LDLIBS) -o $@


$(OBJDIR)/%.o: %.cc
$(CXX) $(CXXFLAGS) $(INCLUDE) -c $< -o $@

-include $(OBJS:.o=.d)

demo.cc






tohare@quantum-solace:~/projects/ftgl-demo$ cat demo.cc
#include // exit()
#include

#include
#include

#include //"FTGLOutlineFont.h"
#include "FTGLPolygonFont.h"
#include "FTGLBitmapFont.h"
#include "FTGLTextureFont.h"
#include "FTGLPixmapFont.h"

static FTFont* fonts[5];
static int width;
static int height;

using namespace std;
void
my_init( const char* font_filename )
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

fonts[0] = new FTGLOutlineFont(font_filename);
fonts[1] = new FTGLPolygonFont(font_filename);
fonts[2] = new FTGLTextureFont(font_filename);
fonts[3] = new FTGLBitmapFont(font_filename);
fonts[4] = new FTGLPixmapFont(font_filename); // looks the best
for (int i=0; i< 5; i++) {
//if (!fonts[i]->Open(font_filename)) {
// cerr << "ERROR: Unable to open file " << font_filename << "\n";
//}
//else {
int point_size = 24;
if (!fonts[i]->FaceSize(point_size)) {
cerr << "ERROR: Unable to set font face size " << point_size << "\n";
}
//}
}
}

static void
do_ortho()
{
int w;
int h;
GLdouble size;
GLdouble aspect;

w = width;
h = height;
aspect = (GLdouble)w / (GLdouble)h;

// Use the whole window.
glViewport(0, 0, w, h);

// We are going to do some 2-D orthographic drawing.
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
size = (GLdouble)((w >= h) ? w : h) / 2.0;
if (w <= h) {
aspect = (GLdouble)h/(GLdouble)w;
glOrtho(-size, size, -size*aspect, size*aspect,
-100000.0, 100000.0);
}
else {
aspect = (GLdouble)w/(GLdouble)h;
glOrtho(-size*aspect, size*aspect, -size, size,
-100000.0, 100000.0);
}

// Make the world and window coordinates coincide so that 1.0 in
// model space equals one pixel in window space.
glScaled(aspect, aspect, 1.0);

// Now determine where to draw things.
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}


void
my_reshape(int w, int h)
{
width = w;
height = h;
}

void
my_handle_key(unsigned char key, int x, int y)
{
switch (key) {

case 27: // Esc - Quits the program.
for (int i=0; i<5; i++) {
if (fonts[i]) {
delete fonts[i];
fonts[i] = 0;
}
}
exit(1);
break;

default:
break;
}
}

void
draw_scene()
{
/* Set up some strings with the characters to draw. */
unsigned int count = 0;
char string[8][256];
int i;
for (i=1; i < 32; i++) { /* Skip zero - it's the null terminator! */
string[0][count] = i;
count++;
}
string[0][count] = '\0';

count = 0;
for (i=32; i < 64; i++) {
string[1][count] = i;
count++;
}
string[1][count] = '\0';

count = 0;
for (i=64; i < 96; i++) {
string[2][count] = i;
count++;
}
string[2][count] = '\0';

count = 0;
for (i=96; i < 128; i++) {
string[3][count] = i;
count++;
}
string[3][count] = '\0';

count = 0;
for (i=128; i < 160; i++) {
string[4][count] = i;
count++;
}
string[4][count] = '\0';

count = 0;
for (i=160; i < 192; i++) {
string[5][count] = i;
count++;
}
string[5][count] = '\0';

count = 0;
for (i=192; i < 224; i++) {
string[6][count] = i;
count++;
}
string[6][count] = '\0';

count = 0;
for (i=224; i < 256; i++) {
string[7][count] = i;
count++;
}
string[7][count] = '\0';


glColor3f(1.0, 1.0, 1.0);

for (int font = 0; font < 5; font++) {
GLfloat x = -250.0;
GLfloat y;
GLfloat yild = 20.0;
for (int j=0; j<4; j++) {
y = 275.0-font*120.0-j*yild;
if (font >= 3) {
glRasterPos2f(x, y);
fonts[font]->Render(string[j]);
}
else {
if (font == 2) {
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
glPushMatrix(); {
glTranslatef(x, y, 0.0);
fonts[font]->Render(string[j]);
} glPopMatrix();
if (font == 2) {
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
}
}
}
}
}


void
my_display(void)
{
glClear(GL_COLOR_BUFFER_BIT);

do_ortho();

draw_scene();

glutSwapBuffers();
}

int
main(int argc, char **argv)
{

glutInitWindowSize(600, 600);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE);

glutCreateWindow("FTGL demo");

int result = 1;
if ( argc != 2 ) {
cerr << "usage: " << argv[0] << " font_filename.ttf\n";
result = 0;
}
else {
my_init(argv[1]);

glutDisplayFunc(my_display);
glutReshapeFunc(my_reshape);
glutKeyboardFunc(my_handle_key);

glutMainLoop();
}
exit(result);
}


Intel chip naming

http://hardware.slashdot.org/comments.pl?sid=1496592&cid=30639436

Intel also has three lines that more or less directly correspond to AMDs: Core/Phenom (good), Pentium/Athlon (ok) and Celeron/Sempron (cheap), plus the server Xeon/Opteron. The real pain is the amount of different model numbers and numbering schemes. The secret decoder ring for Intel models is:

A) old three number codes
E.g. Pentium 965, Celeron 450, ...
First digit is the model, second digit corresponds to the speed
These are usually old crap and should be avoided. Celeron 743 and Celeron 900 fairly recent low-end chips that you can still buy.

B) Letter plus four numbers codes, e.g. SU7300:
* S = small form factor
* U = ultra-low voltage (5-10W), L = low-voltage (17W), P = medium voltage (25W), T = desktop replacement (35W), E = Desktop (65W), Q = quad-core (65-130W), X = extreme edition
* 7 = model line, tells you about amount of cache, VT capability etc. Scale goes from 1 (crap) to 9 (can't afford).
* 3 = clock frequency, relative performance within the line. Scale from 0 to 9.
* 00 = random features disabled or enabled, have to look up for specific details.

C) New Core i3-XYZa
Similar to scheme B, with the added dash and more confusing
* i3 = Line within Core brand, can be i3 (cheap, but better than Celeron or Pentium), i5 (decent) or i7 (high-end)
* X = the actual model, tells you the amount of cache and number of cores, but only together with the processor line (i3-5xx is very different from i5-5xx)
* Y = corresponds to clock speed, higher is better
* Z = modifier, currently 0, 1 or 5 for specific features
* a = type of processor: X = extreme, M = mobile, QM = quad-core mobile, LM = low-voltage mobile, UM = ultra-low-voltage mobile