void defineAudio()
{
VALUE cVector3f = defClass<Vector3f>("Vector3f");
defMethod(cVector3f, "x=", Vector3f_setX, 1);
defMethod(cVector3f, "y=", Vector3f_setY, 1);
defMethod(cVector3f, "z=", Vector3f_setZ, 1);
defMethod(cVector3f, "x", Vector3f_x, 0);
defMethod(cVector3f, "y", Vector3f_y, 0);
defMethod(cVector3f, "z", Vector3f_z, 0);
defMethod(cVector3f, "+", Vector3f_add, 1);
defMethod(cVector3f, "-", Vector3f_sub, 1);
defMethod(cVector3f, "==", Vector3f_eq, 1);
VALUE cAudioObject = defClass<AudioObject>("AudioObject");
defMethod(cAudioObject, "setPos", AudioObject_setPos, 3);
defMethod(cAudioObject, "setDirection", AudioObject_setDirection, 3);
defMethod(cAudioObject, "setVelocity", AudioObject_setVelocity, 3);
defMethod(cAudioObject, "pos=", AudioObject_setPosVector, 1);
defMethod(cAudioObject, "direction=", AudioObject_setDirectionVector, 1);
defMethod(cAudioObject, "velocity=", AudioObject_setVelocityVector, 1);
defMethod(cAudioObject, "playing?", AudioObject_playing, 0);
VALUE cSound = defClass<Sound>("Sound", "AudioObject");
defMethod(cSound, "loadWav", Sound_loadWav, 1);
defMethod(cSound, "play", Sound_play, 0);
defMethod(cSound, "pause", Sound_play, 0);
defMethod(cSound, "stop", Sound_stop, 0);
defAlias(cSound, "loadWav", "load_wav");
VALUE cStream = defClass<Stream>("Stream", "AudioObject");
defMethod(cStream, "loadOgg", Stream_loadOgg, 1);
defMethod(cStream, "play", Stream_play, 0);
defMethod(cStream, "update", Stream_update, 0);
defMethod(cStream, "pause", Stream_play, 0);
defMethod(cStream, "stop", Stream_stop, 0);
defAlias(cStream, "loadOgg", "load_ogg");
VALUE mListener = defModule("Listener");
defModFunc(mListener, "setPos", Listener_setPos, 3);
defModFunc(mListener, "setDirection", Listener_setDirection, 3);
defModFunc(mListener, "setVelocity", Listener_setVelocity, 3);
defModFunc(mListener, "pos=", Listener_posOp, 1);
defModFunc(mListener, "direction=", Listener_directionOp, 1);
defModFunc(mListener, "velocity=", Listener_velocityOp, 1);
defModFunc(mListener, "setOrientation", Listener_setOrientation, 6);
VALUE joyau = JOYAU_MOD;
defModFunc(joyau, "initAudio", Audio_init, 0);
defModFunc(joyau, "stopAudio", Audio_stop, 0);
}
void defineParticles()
{
VALUE cPart = defClass<Particles>("Particles", "Drawable");
defMethod(cPart, "setFile", Particles_setFile, 1);
defMethod(cPart, "setParam", Particles_setParam, 4);
defMethod(cPart, "addParticles", Particles_addParticles, 2);
defMethod(cPart, "getTime", Particles_getTime, 0);
defMethod(cPart, "getSpeed", Particles_getSpeed, 0);
defMethod(cPart, "getGravity", Particles_getGravity, 0);
defMethod(cPart, "getMinSpeed", Particles_getMinSpeed, 0);
defAlias(cPart, "setFile", "file=");
defAlias(cPart, "getTime", "time");
defAlias(cPart, "getSpeed", "speed");
defAlias(cPart, "getGravity", "gravity");
defAlias(cPart, "getMinSpeed", "minSpeed");
}
void defineShape()
{
VALUE cShape = defClass<Shape>("Shape", "Drawable");
defMethod(cShape, "setColor", Shape_setColor, -1);
defMethod(cShape, "setGradient", Shape_setGradient, 1);
defMethod(cShape, "getColors", Shape_getColors, 0);
defMethod(cShape, "getColor", Shape_getColor, 0);
defMethod(cShape, "getColorsNumber", Shape_getColorsNumber, 0);
VALUE cFillableShape = defClass<FillableShape>("FillableShape", "Shape");
defMethod(cFillableShape, "toggleFilled", FillableShape_toggleFilled, 0);
defMethod(cFillableShape, "filled", FillablleShape_filled, 0);
defMethod(cFillableShape, "filled=", FillableShape_setFilled, 1);
defAlias(cShape, "setColor", "color=");
defAlias(cShape, "setGradient", "gradient=");
defAlias(cShape, "getColors", "colors");
defAlias(cShape, "getColor", "color");
defAlias(cShape, "getColorsNumber", "colorsNumber");
}
void defineScrolling()
{
VALUE cScroll = defClass<Scrolling>("Scrolling", "Drawable");
defMethod(cScroll, "initialize", Scrolling_initialize, -1);
defMethod(cScroll, "setSprite", Scrolling_setSprite, 1);
defMethod(cScroll, "setDir", Scrolling_setDir, 1);
defMethod(cScroll, "setSpeed", Scrolling_setSpeed, 1);
defMethod(cScroll, "dir", Scrolling_dir, 0);
defMethod(cScroll, "speed", Scrolling_speed, 0);
defMethod(cScroll, "play", Scrolling_play, 0);
defAlias(cScroll, "setSprite", "sprite=");
defAlias(cScroll, "setDir", "dir=");
defAlias(cScroll, "dir", "direction");
defAlias(cScroll, "setDir", "direction=");
defAlias(cScroll, "setSpeed", "speed=");
defConst(cScroll, "LEFT", INT2FIX(Sprite::LEFT));
defConst(cScroll, "RIGHT", INT2FIX(Sprite::RIGHT));
defConst(cScroll, "UP", INT2FIX(Sprite::UP));
defConst(cScroll, "DOWN", INT2FIX(Sprite::DOWN));
}
void defineGameMap()
{
VALUE cCollisionType = defClass<CollisionType>("CollisionType");
defMethod(cCollisionType, "initialize", CollisionType_initialize, -1);
defMethod(cCollisionType, "left", CollisionType_left, 0);
defMethod(cCollisionType, "right", CollisionType_right, 0);
defMethod(cCollisionType, "up", CollisionType_up, 0);
defMethod(cCollisionType, "down", CollisionType_down, 0);
defMethod(cCollisionType, "content", CollisionType_content, 0);
defMethod(cCollisionType, "left=", CollisionType_setLeft, 1);
defMethod(cCollisionType, "right=", CollisionType_setRight, 1);
defMethod(cCollisionType, "up=", CollisionType_setUp, 1);
defMethod(cCollisionType, "down=", CollisionType_setDown, 1);
defMethod(cCollisionType, "content=", CollisionType_setContent, 1);
VALUE cTile = defClass<GameMap::Tile>("Tile");
defMethod(cTile, "initialize", GameMap_Tile_initialize, -1);
defMethod(cTile, "x", Tile_x, 0);
defMethod(cTile, "y", Tile_y, 0);
defMethod(cTile, "tileset", Tile_tileset, 0);
defMethod(cTile, "tileX", Tile_tileX, 0);
defMethod(cTile, "tileY", Tile_tileY, 0);
defMethod(cTile, "type", Tile_type, 0);
defMethod(cTile, "x=", Tile_setX, 1);
defMethod(cTile, "y=", Tile_setY, 1);
defMethod(cTile, "tileset=", Tile_setTileset, 1);
defMethod(cTile, "tileX=", Tile_setTileX, 1);
defMethod(cTile, "tileY=", Tile_setTileY, 1);
defMethod(cTile, "type=", Tile_setType, 1);
VALUE cMap = defClass<GameMap>("GameMap", "Drawable");
defMethod(cMap, "initialize", GameMap_initialize, -1);
defMethod(cMap, "addTileset", GameMap_addTileset, 1);
defMethod(cMap, "setTileSize", GameMap_setTileSize, 2);
defMethod(cMap, "tileWidth", GameMap_tileWidth, 0);
defMethod(cMap, "tileHeight", GameMap_tileHeight, 0);
defMethod(cMap, "collisionH=", GameMap_setCollisionH, 1);
defMethod(cMap, "collisionH", GameMap_collisionH, 0);
defMethod(cMap, "absToRel", GameMap_absToRel, 2);
defMethod(cMap, "relToAbs", GameMap_relToAbs, 2);
defMethod(cMap, "centerOn", GameMap_centerOn, 2);
defMethod(cMap, "addElem", GameMap_addElem, -1);
defMethod(cMap, "<<", GameMap_push, 1);
defMethod(cMap, "clear", GameMap_clear, 0);
defMethod(cMap, "clearTiles", GameMap_clearTiles, 0);
defMethod(cMap, "clear_between", GameMap_clearBetween, 0);
defMethod(cMap, "tiles", GameMap_tiles, 0);
defMethod(cMap, "tilesets", GameMap_tilesets, 0);
defMethod(cMap, "each_tile", GameMap_each_tile, 0);
defMethod(cMap, "each_tileset", GameMap_each_tileset, 0);
defMethod(cMap, "reject_tiles", GameMap_reject_tiles, 0);
defMethod(cMap, "addBetween", GameMap_addBetween, 1);
defAlias(cMap, "addTileset", "add_tileset");
defAlias(cMap, "setTileSize", "set_tile_size");
defAlias(cMap, "tileWidth", "tile_width");
defAlias(cMap, "tileHeight", "tile_height");
defAlias(cMap, "collisionH", "collision_h");
defAlias(cMap, "collisionH=", "collision_h=");
defAlias(cMap, "absToRel", "abs2rel");
defAlias(cMap, "relToAbs", "rel2abs");
defAlias(cMap, "centerOn", "center_on");
defAlias(cMap, "addElem", "add_elem");
defAlias(cMap, "clearTiles", "clear_tiles");
CollisionType full(true, false, false, false, false);
CollisionType left(false, true, false, false, false);
CollisionType right(false, false, true, false, false);
CollisionType up(false, false, false, true, false);
CollisionType down(false, false, false, false, true);
CollisionType no(false, false, false, false, false);
CollisionType left_right(false, true, true, false, false);
CollisionType left_up(false, true, false, true, false);
CollisionType left_down(false, true, false, false, true);
CollisionType right_up(false, false, true, true, false);
CollisionType right_down(false, false, true, false, true);
CollisionType up_down(false, false, false, true, true);
/*
Document-const: COL_FULL
Joyau::CollisionType.new(true, false, false, false, false): Collision with
everything.
*/
/*
Document-const: COL_LEFT
Joyau::CollisionType.new(false, true, false, false, false): Collision with
the left side.
*/
/*
Document-const: COL_RIGHT
Joyau::CollisionType.new(false, false, true, false, false): Collision with
the right side.
*/
/*
Document-const: COL_UP
Joyau::CollisionType.new(false, false, false, true, false): Collision with
the upper side.
*/
/*
Document-const: COL_DOWN
Joyau::CollisionType.new(false, false, false, false, true): Collision with
the downer side.
*/
/*
Document-const: COL_NO
Joyau::CollisionType.new(false, false, false, false, false): Collision
with nothing.
*/
/*
Document-const: COL_LEFT_RIGHT
Joyau::CollisionType.new(false, true, true, false, false): Collision with
the left and right sides.
*/
/*
Document-const: COL_LEFT_UP
Joyau::CollisionType.new(false, true, false, true, false): Collision with
the left and the upper sides.
*/
/*
Document-const: COL_LEFT_DOWN
Joyau::CollisionType.new(false, true, false, false, true): Collision with
the left and the downer sides.
*/
/*
Document-const: COL_RIGHT_UP
Joyau::CollisionType.new(false, false, true, true, false): Collision with
the right and the upper sides.
*/
/*
Document-const: COL_RIGHT_DOWN
Joyau::CollisionType.new(false, false, true, false, true): Collision with
the right and the downer sides.
*/
/*
Document-const: COL_UP_DOWN
Joyau::CollisionType.new(false, false, false, true, true): Collision with
the upper and the downer sides.
*/
defConst(cMap, "COL_FULL", createObject(cCollisionType, full));
defConst(cMap, "COL_LEFT", createObject(cCollisionType, left));
defConst(cMap, "COL_RIGHT", createObject(cCollisionType, right));
defConst(cMap, "COL_UP", createObject(cCollisionType, up));
defConst(cMap, "COL_DOWN", createObject(cCollisionType, down));
defConst(cMap, "COL_NO", createObject(cCollisionType, no));
defConst(cMap, "COL_LEFT_RIGHT", createObject(cCollisionType, left_right));
defConst(cMap, "COL_LEFT_UP", createObject(cCollisionType, left_up));
defConst(cMap, "COL_LEFT_DOWN", createObject(cCollisionType, left_down));
defConst(cMap, "COL_RIGHT_UP", createObject(cCollisionType, right_up));
defConst(cMap, "COL_RIGHT_DOWN", createObject(cCollisionType, right_down));
defConst(cMap, "COL_UP_DOWN", createObject(cCollisionType, up_down));
}
void defineDrawable()
{
VALUE cPoint = defClass<Point>("Point");
defMethod(cPoint, "x", Point_getX, 0);
defMethod(cPoint, "y", Point_getY, 0);
defMethod(cPoint, "x=", Point_setX, 1);
defMethod(cPoint, "y=", Point_setY, 1);
defMethod(cPoint, "+", Point_add, 1);
defMethod(cPoint, "-", Point_sub, 1);
defMethod(cPoint, "==", Point_eq, 1);
VALUE cRect = defClass<Rect>("Rect");
defMethod(cRect, "x", Rect_getX, 0);
defMethod(cRect, "y", Rect_getY, 0);
defMethod(cRect, "w", Rect_getW, 0);
defMethod(cRect, "h", Rect_getH, 0);
defMethod(cRect, "x=", Rect_setX, 1);
defMethod(cRect, "y=", Rect_setY, 1);
defMethod(cRect, "w=", Rect_setW, 1);
defMethod(cRect, "h=", Rect_setH, 1);
VALUE cDrawable = defClass<Drawable>("Drawable");
defMethod(cDrawable, "boundingRect", Drawable_boundingRect, 0);
defMethod(cDrawable, "collide", Drawable_collide, 1);
defMethod(cDrawable, "isOn", Drawable_isOn, 2);
defMethod(cDrawable, "getX", Drawable_getX, 0);
defMethod(cDrawable, "getY", Drawable_getY, 0);
defMethod(cDrawable, "x=", Drawable_setX, 1);
defMethod(cDrawable, "y=", Drawable_setY, 1);
defMethod(cDrawable, "movedX", Drawable_movedX, 0);
defMethod(cDrawable, "movedY", Drawable_movedY, 0);
defMethod(cDrawable, "getW", Drawable_getW, 0);
defMethod(cDrawable, "getH", Drawable_getH, 0);
defMethod(cDrawable, "setPos", Drawable_setPos, 2);
defMethod(cDrawable, "pos=", Drawable_setPoint, 1);
defMethod(cDrawable, "move", Drawable_move, 2);
defMethod(cDrawable, "cancelMove", Drawable_cancelMove, 0);
defMethod(cDrawable, "clearMove", Drawable_clearMove, 0);
defMethod(cDrawable, "draw", Drawable_draw, 0);
defMethod(cDrawable, "to_buf", Drawable_to_buf, 0);
defAlias(cDrawable, "getX", "x");
defAlias(cDrawable, "getY", "y");
defAlias(cDrawable, "getW", "w");
defAlias(cDrawable, "getH", "h");
defAlias(cDrawable, "collide", "collide?");
defAlias(cDrawable, "isOn", "is_on?");
defAlias(cDrawable, "boundingRect", "bounding_rect");
defAlias(cDrawable, "movedX", "moved_x");
defAlias(cDrawable, "movedY", "moved_y");
defAlias(cDrawable, "cancelMove", "cancel_move");
defAlias(cDrawable, "clearMove", "clear_move");
}
void defineBuffer() {
VALUE cBuffer = defClass<Buffer>("Buffer");
/*
Document-const: PF_4444
PF_4444: Pixel format for 8 bits colors.
*/
/*
Document-const: PF_5650
PF_5650: Pixel format for 16 bits colors.
*/
/*
Document-const: PF_8888
PF_8888: Pixel format for 32 bits colors.
*/
defConst(cBuffer, "PF_4444", INT2FIX(OSL_PF_4444));
defConst(cBuffer, "PF_5650", INT2FIX(OSL_PF_5650));
defConst(cBuffer, "PF_8888", INT2FIX(OSL_PF_8888));
defMethod(cBuffer, "initialize", Buffer_initialize, -1);
defMethod(cBuffer, "set_actual", Buffer_setActual, 0);
defMethod(cBuffer, "draw", Buffer_draw, -1);
defMethod(cBuffer, "clear", Buffer_clear, 1);
defMethod(cBuffer, "x", Buffer_getX, 0);
defMethod(cBuffer, "y", Buffer_getY, 0);
defMethod(cBuffer, "w", Buffer_getW, 0);
defMethod(cBuffer, "h", Buffer_getH, 0);
defMethod(cBuffer, "x=", Buffer_setX, 1);
defMethod(cBuffer, "y=", Buffer_setY, 1);
defMethod(cBuffer, "setPos", Buffer_setPos, -1);
defMethod(cBuffer, "move", Buffer_move, 2);
defMethod(cBuffer, "resize", Buffer_resize, 2);
defMethod(cBuffer, "zoom", Buffer_zoom, 1);
defMethod(cBuffer, "rotate", Buffer_rotate, 1);
defMethod(cBuffer, "lock", Buffer_lock, -1);
defMethod(cBuffer, "unlock", Buffer_unlock, 0);
defMethod(cBuffer, "[]", Buffer_getPixel, 2);
defMethod(cBuffer, "[]=", Buffer_setPixel, 3);
defMethod(cBuffer, "save", Buffer_save, 1);
defMethod(cBuffer, "to_sprite", Buffer_to_sprite, 0);
defClassMethod(cBuffer, "screen", Buffer_getScreen, 0);
defClassMethod(cBuffer, "default", Buffer_getDefault, 0);
defClassMethod(cBuffer, "actual", Buffer_getActual, 0);
defClassMethod(cBuffer, "[]", Buffer_find, -1);
defAlias(cBuffer, "setPos", "pos=");
VALUE cPainter = defClass<Painter>("Painter");
defMethod(cPainter, "initialize", Painter_initialize, 1);
defMethod(cPainter, "drawLine", Painter_drawLine, -1);
defMethod(cPainter, "drawFillRect", Painter_drawFillRect, -1);
defMethod(cPainter, "drawRect", Painter_drawRect, -1);
defMethod(cPainter, "drawPoint", Painter_drawPoint, 3);
defMethod(cPainter, "drawCircle", Painter_drawCircle, 4);
defMethod(cPainter, "drawFillCircle", Painter_drawFillCircle, 4);
defMethod(cPainter, "drawTriangle", Painter_drawTriangle, -1);
defMethod(cPainter, "drawBuffer", Painter_drawBuffer, 3);
defMethod(cPainter, "clear", Painter_clear, 1);
VALUE joyau = JOYAU_MOD;
defModFunc(joyau, "draw", Joyau_draw, -1);
}
void defineKeys()
{
VALUE keys = rb_hash_new();
rb_gv_set("$keys", keys);
VALUE joyau = JOYAU_MOD;
defModFunc(joyau, "readKeys", checkKeys, 0);
defModFunc(joyau, "gets", Joyau_gets, 0);
VALUE mPad = defModule("Pad");
defModFunc(mPad, "update", Pad_update, 0);
defModFunc(mPad, "held?", Pad_held, 1);
defModFunc(mPad, "pressed?", Pad_pressed, 1);
defModFunc(mPad, "released?", Pad_released, 1);
defModFunc(mPad, "stickX", Pad_stickX, 0);
defModFunc(mPad, "stickY", Pad_stickY, 0);
defConst(mPad, "SELECT", INT2FIX(PSP_CTRL_SELECT));
defConst(mPad, "START", INT2FIX(PSP_CTRL_START));
defConst(mPad, "L", INT2FIX(PSP_CTRL_LTRIGGER));
defConst(mPad, "R", INT2FIX(PSP_CTRL_RTRIGGER));
defConst(mPad, "CROSS", INT2FIX(PSP_CTRL_CROSS));
defConst(mPad, "SQUARE", INT2FIX(PSP_CTRL_SQUARE));
defConst(mPad, "TRIANGLE", INT2FIX(PSP_CTRL_TRIANGLE));
defConst(mPad, "CIRCLE", INT2FIX(PSP_CTRL_CIRCLE));
defConst(mPad, "UP", INT2FIX(PSP_CTRL_UP));
defConst(mPad, "DOWN", INT2FIX(PSP_CTRL_DOWN));
defConst(mPad, "LEFT", INT2FIX(PSP_CTRL_LEFT));
defConst(mPad, "RIGHT", INT2FIX(PSP_CTRL_RIGHT));
defConst(mPad, "HOLD", INT2FIX(PSP_CTRL_HOLD));
/*
Document-class: Joyau::OSK
There is a built-in keyboard in your firmware, which can be used by your
program easily through this class. Notice Joyau.gets is a simpliefied
version of this module, which can handle more advanced settings.
You can, by using its constants, specify what has to be input.
you can indicated the used language:
1. DEFAULT
2. JAPANESE
3. ENGLISH
4. FRENCH
5. SPANISH
6. GERMAN
7. ITALIAN
8. DUTCH
9. PORTUGESE
10. RUSSIAN
11. KOREAN
As well as the caracters to input:
1. ALL
2. LATIN_SYMBOL
3. LATIN_LOWERCASE
4. LATIN_UPPERCASE
5. LATIN_DIGIT
6. JAPANESE_DIGIT
7. JAPANESE_SYMBOL
8. JAPANESE_LOWERCASE
9. JAPANESE_UPPERCASE
10. JAPANESE_HIRAGANA
11. JAPANASE_HALF_KATAKANA
12. JAPANESE_KATAKANA
13. JAPANESE_LOWERCASE
14. RUSSIAN_LOWERCASE
15. RUSSIAN_UPPERCASE
16. IT_KOREAN
17. URL
You can also set the default text and the description, and give a block
telling what to draw under the keyboard (if nothing were drawn, there'd
be graphical glitches).
*/
VALUE mOSK = defModule("OSK");
defModFunc(mOSK, "run", Osk_run, 5);
defConst(mOSK, "DEFAULT", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_DEFAULT));
defConst(mOSK, "JAPANESE", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_JAPANESE));
defConst(mOSK, "ENGLISH", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_ENGLISH));
defConst(mOSK, "FRENCH", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_SPANISH));
defConst(mOSK, "SPANISH", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_SPANISH));
defConst(mOSK, "GERMAN", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_GERMAN));
defConst(mOSK, "ITALIAN", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_ITALIAN));
defConst(mOSK, "PORTUGESE", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_PORTUGESE));
defConst(mOSK, "RUSSIAN", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_RUSSIAN));
defConst(mOSK, "KOREAN", INT2FIX(PSP_UTILITY_OSK_LANGUAGE_KOREAN));
defConst(mOSK, "ALL", INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_ALL));
defConst(mOSK, "LATIN_DIGIT",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_LATIN_DIGIT));
defConst(mOSK, "LATIN_SYMBOL",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_LATIN_SYMBOL));
defConst(mOSK, "LATIN_LOWERCASE",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_LATIN_LOWERCASE));
defConst(mOSK, "LATIN_UPPERCASE",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_LATIN_UPPERCASE));
defConst(mOSK, "JAPANESE_DIGIT",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_DIGIT));
defConst(mOSK, "JAPANESE_SYMBOL",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_SYMBOL));
defConst(mOSK, "JAPANESE_LOWERCASE",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_LOWERCASE));
defConst(mOSK, "JAPANESE_UPPERCASE",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_UPPERCASE));
defConst(mOSK, "JAPANESE_HIRAGANA",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_HIRAGANA));
defConst(mOSK, "JAPANASE_HALF_KATAKANA",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_HALF_KATAKANA));
defConst(mOSK, "JAPANESE_KATAKANA",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_KATAKANA));
defConst(mOSK, "RUSSIAN_LOWERCASE",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_JAPANESE_LOWERCASE));
defConst(mOSK, "RUSSIAN_UPPERCASE",
INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_RUSSIAN_UPPERCASE));
defConst(mOSK, "IT_KOREAN", INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_KOREAN));
defConst(mOSK, "URL", INT2FIX(PSP_UTILITY_OSK_INPUTTYPE_URL));
VALUE cCursor = defClass<Cursor>("Cursor", "Sprite");
defMethod(cCursor, "updatePos", Cursor_updatePos, 0);
defMethod(cCursor, "setSensibility", Cursor_setSensibility, 1);
defMethod(cCursor, "sensibility", Cursor_sensibility, 0);
defMethod(cCursor, "rect=", Cursor_setRect, 1);
defMethod(cCursor, "rect", Cursor_rect, 0);
defAlias(cCursor, "setSensibility", "sensibility=");
defAlias(cCursor, "updatePos", "update_pos");
}