Examples with Buffer org.luaj.vm2.Buffer used on opensource projects

Example 1 with Buffer

use of org.luaj.vm2.Buffer in project LuaViewSDK by alibaba.

the class StringLib method format.

/**
     * string.format (formatstring, ...)
     *
     * Returns a formatted version of its variable number of arguments following
     * the description given in its first argument (which must be a string).
     * The format string follows the same rules as the printf family of standard C functions.
     * The only differences are that the options/modifiers *, l, L, n, p, and h are not supported
     * and that there is an extra option, q. The q option formats a string in a form suitable
     * to be safely read back by the Lua interpreter: the string is written between double quotes,
     * and all double quotes, newlines, embedded zeros, and backslashes in the string are correctly
     * escaped when written. For instance, the call
     *   string.format('%q', 'a string with "quotes" and \n new line')
     *
     * will produce the string:
     *    "a string with \"quotes\" and \
     *    new line"
     *
     * The options c, d, E, e, f, g, G, i, o, u, X, and x all expect a number as argument,
     * whereas q and s expect a string.
     *
     * This function does not accept string values containing embedded zeros,
     * except as arguments to the q option.
     */
static Varargs format(Varargs args) {
    LuaString fmt = args.checkstring(1);
    final int n = fmt.length();
    Buffer result = new Buffer(n);
    int arg = 1;
    int c;
    for (int i = 0; i < n; ) {
        switch(c = fmt.luaByte(i++)) {
            case '\n':
                result.append("\n");
                break;
            default:
                result.append((byte) c);
                break;
            case L_ESC:
                if (i < n) {
                    if ((c = fmt.luaByte(i)) == L_ESC) {
                        ++i;
                        result.append((byte) L_ESC);
                    } else {
                        arg++;
                        FormatDesc fdsc = new FormatDesc(args, fmt, i);
                        i += fdsc.length;
                        switch(fdsc.conversion) {
                            case 'c':
                                fdsc.format(result, (byte) args.checkint(arg));
                                break;
                            case 'i':
                            case 'd':
                                fdsc.format(result, args.checkint(arg));
                                break;
                            case 'o':
                            case 'u':
                            case 'x':
                            case 'X':
                                fdsc.format(result, args.checklong(arg));
                                break;
                            case 'e':
                            case 'E':
                            case 'f':
                            case 'g':
                            case 'G':
                                fdsc.format(result, args.checkdouble(arg), fdsc.precision);
                                break;
                            case 'q':
                                addquoted(result, args.checkstring(arg));
                                break;
                            case 's':
                                {
                                    LuaString s = args.checkstring(arg);
                                    if (fdsc.precision == -1 && s.length() >= 100) {
                                        result.append(s);
                                    } else {
                                        fdsc.format(result, s);
                                    }
                                }
                                break;
                            default:
                                error("invalid option '%" + (char) fdsc.conversion + "' to 'format'");
                                break;
                        }
                    }
                }
        }
    }
    return result.tostring();
}

Example 2 with Buffer

use of org.luaj.vm2.Buffer in project LuaViewSDK by alibaba.

the class LuaPrint method buildState.

/**
     * Print the state of a {@link LuaClosure} that is being executed
     *
     * @param cl      the {@link LuaClosure}
     * @param pc      the program counter
     * @param stack   the stack of {@link LuaValue}
     * @param top     the top of the stack
     * @param varargs any {@link Varargs} value that may apply
     */
public LuaPrint buildState(LuaClosure cl, int pc, LuaValue[] stack, int top, Varargs varargs) {
    // print opcode into buffer
    StringBuffer previous = ps;
    ps = new StringBuffer();
    buildOpCode(cl.p, pc);
    LogUtil.i(ps);
    ps = previous;
    format(ps.toString(), 50);
    // print stack
    ps.append('[');
    for (int i = 0; i < stack.length; i++) {
        LuaValue v = stack[i];
        if (v == null)
            ps.append(STRING_FOR_NULL);
        else
            switch(v.type()) {
                case LuaValue.TSTRING:
                    LuaString s = v.checkstring();
                    ps.append(s.length() < 48 ? s.tojstring() : s.substring(0, 32).tojstring() + "...+" + (s.length() - 32) + "b");
                    break;
                case LuaValue.TFUNCTION:
                    ps.append(v.tojstring());
                    break;
                case LuaValue.TUSERDATA:
                    Object o = v.touserdata();
                    if (o != null) {
                        String n = o.getClass().getName();
                        n = n.substring(n.lastIndexOf('.') + 1);
                        ps.append(n + ": " + Integer.toHexString(o.hashCode()));
                    } else {
                        ps.append(v.toString());
                    }
                    break;
                default:
                    ps.append(v.tojstring());
            }
        if (i + 1 == top)
            ps.append(']');
        ps.append(" | ");
    }
    ps.append(varargs);
    ps.append("\n");
    return this;
}

Example 3 with Buffer

use of org.luaj.vm2.Buffer in project love-android by hagish.

the class LuanGraphics method InitLib.

public LuaTable InitLib() {
    InitRenderer();
    try {
        mDefaultFont = new LuanObjFont(this);
        mFont = mDefaultFont;
    } catch (Exception e) {
        Log("warning, failed to load default font in LuanGraphics:InitLib");
    //~ vm.handleError(e);
    }
    LuaTable t = LuaValue.tableOf();
    LuaValue _G = vm.get_G();
    _G.set(sMetaName_LuanImage, LuanObjImage.CreateMetaTable(this));
    _G.set(sMetaName_LuanQuad, LuanObjQuad.CreateMetaTable(this));
    _G.set(sMetaName_LuanFont, LuanObjFont.CreateMetaTable(this));
    _G.set(sMetaName_LuanParticleSystem, LuanObjParticleSystem.CreateMetaTable(this));
    // ***** ***** ***** ***** ***** rest
    // TODO: not yet implemented	
    t.set("checkMode", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "checkMode");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getCaption", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getCaption");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("isCreated", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "isCreated");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("newFramebuffer", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "newFramebuffer");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("newScreenshot", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "newScreenshot");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("newSpriteBatch", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "newSpriteBatch");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("pop", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "pop");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("push", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "push");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("present", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "present");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setCaption", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setCaption");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setIcon", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setIcon");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setRenderTarget", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setRenderTarget");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("toggleFullscreen", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "toggleFullscreen");
            return LuaValue.NONE;
        }
    });
    // ***** ***** ***** ***** ***** rendering options
    // TODO: not yet implemented
    t.set("getBackgroundColor", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getBackgroundColor");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getBlendMode", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getBlendMode");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getColor", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getColor");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getColorMode", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getColorMode");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setLine", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setLine");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setLineStipple", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setLineStipple");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setLineStyle", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setLineStyle");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setLineWidth", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setLineWidth");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setPoint", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setPoint");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setPointSize", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setPointSize");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("setPointStyle", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "setPointStyle");
            return LuaValue.NONE;
        }
    });
    // love.graphics.setScissor( )
    // love.graphics.setScissor( x, y, width, height )
    t.set("setScissor", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            if (args.narg() == 0) {
                setScissor();
            } else if (args.narg() == 4) {
                setScissor(args.checkint(1), args.checkint(2), args.checkint(3), args.checkint(4));
            }
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getLineStipple", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getLineStipple");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getLineStyle", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getLineStyle");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getLineWidth", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getLineWidth");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getMaxPointSize", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getMaxPointSize");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getModes", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getModes");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getPointSize", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getPointSize");
            return LuaValue.NONE;
        }
    });
    // TODO: not yet implemented
    t.set("getPointStyle", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getPointStyle");
            return LuaValue.NONE;
        }
    });
    // x, y, width, height = love.graphics.getScissor( )
    t.set("getScissor", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            if (isScissorEnabled()) {
                Rectangle scissorBox = getScissorBox();
                return LuaValue.tableOf(new LuaValue[] { LuaValue.valueOf(scissorBox.left), LuaValue.valueOf(scissorBox.top), LuaValue.valueOf(scissorBox.width), LuaValue.valueOf(scissorBox.height) });
            } else {
                return LuaValue.NONE;
            }
        }
    });
    t.set("setBlendMode", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            setBlendMode(Str2BlendMode(args.checkjstring(1)));
            return LuaValue.NONE;
        }
    });
    t.set("setColorMode", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            setColorMode(Str2ColorMode(args.checkjstring(1)));
            return LuaValue.NONE;
        }
    });
    /// love.graphics.setBackgroundColor( red, green, blue )  // 0-255
    t.set("setBackgroundColor", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            LuanColor rgba = new LuanColor(args);
            setBackgroundColor(rgba);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.setColor( red, green, blue, alpha )  // 0-255
    t.set("setColor", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            LuanColor rgba = new LuanColor(args);
            setForegroundColor(rgba);
            return LuaValue.NONE;
        }
    });
    // ***** ***** ***** ***** ***** basic geometry rendering
    /// love.graphics.quad( mode, x1, y1, x2, y2, x3, y3, x4, y4 )
    t.set("quad", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            DrawMode mode = Str2DrawMode(args.checkjstring(1));
            float x1 = (float) args.checkdouble(2);
            float y1 = (float) args.checkdouble(3);
            float x2 = (float) args.checkdouble(4);
            float y2 = (float) args.checkdouble(5);
            float x3 = (float) args.checkdouble(6);
            float y3 = (float) args.checkdouble(7);
            float x4 = (float) args.checkdouble(8);
            float y4 = (float) args.checkdouble(9);
            renderQuad(mode, x1, y1, x2, y2, x3, y3, x4, y4);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.triangle( mode, x1, y1, x2, y2, x3, y3 )
    t.set("triangle", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            DrawMode mode = Str2DrawMode(args.checkjstring(1));
            float x1 = (float) args.checkdouble(2);
            float y1 = (float) args.checkdouble(3);
            float x2 = (float) args.checkdouble(4);
            float y2 = (float) args.checkdouble(5);
            float x3 = (float) args.checkdouble(6);
            float y3 = (float) args.checkdouble(7);
            renderTriangle(mode, x1, y1, x2, y2, x3, y3);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.circle( mode, x, y, radius, segments = 10 )
    t.set("circle", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            DrawMode mode = Str2DrawMode(args.checkjstring(1));
            float x = (float) args.checkdouble(2);
            float y = (float) args.checkdouble(3);
            float radius = (float) args.checkdouble(4);
            int segments = IsArgSet(args, 5) ? args.checkint(5) : 10;
            renderCircle(mode, x, y, radius, segments);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.point( x, y )
    t.set("point", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            float x = (float) args.checkdouble(1);
            float y = (float) args.checkdouble(2);
            renderPoint(x, y);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.rectangle( mode, x, y, width, height )
    t.set("rectangle", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            DrawMode mode = Str2DrawMode(args.checkjstring(1));
            float x = (float) args.checkdouble(2);
            float y = (float) args.checkdouble(3);
            float w = (float) args.checkdouble(4);
            float h = (float) args.checkdouble(5);
            renderRectangle(mode, x, y, w, h);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.line( x1, y1, x2, y2, ... )
    t.set("line", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            if (IsArgSet(args, 5)) {
                renderPolyLine(FloatArray(args, 1));
            } else {
                float x1 = (float) args.checkdouble(1);
                float y1 = (float) args.checkdouble(2);
                float x2 = (float) args.checkdouble(3);
                float y2 = (float) args.checkdouble(4);
                renderLine(x1, y1, x2, y2);
            }
            return LuaValue.NONE;
        }
    });
    /// love.graphics.polygon( mode, ... )
    /// Note: when in fill mode, the polygon must be convex and simple or rendering artifacts may occur. 
    t.set("polygon", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            DrawMode mode = Str2DrawMode(args.checkjstring(1));
            renderPolygon(mode, FloatArray(args, 2));
            return LuaValue.NONE;
        }
    });
    /// love.graphics.clear ( )
    /// Clears the screen to background color. 
    t.set("clear", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            getGL().glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
            return LuaValue.NONE;
        }
    });
    // ***** ***** ***** ***** ***** font + text
    // TODO: not yet implemented
    t.set("getFont", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            vm.NotImplemented("love.graphics." + "getFont");
            return LuaValue.NONE;
        }
    });
    /// love.graphics.print( text, x, y, r, sx, sy )
    /// Draws text on screen.
    t.set("print", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            String s = args.checkjstring(1);
            float x = (float) args.checkdouble(2);
            float y = (float) args.checkdouble(3);
            float r = (IsArgSet(args, 4)) ? ((float) args.checkdouble(4)) : 0f;
            float sx = (IsArgSet(args, 5)) ? ((float) args.checkdouble(5)) : 1f;
            float sy = (IsArgSet(args, 6)) ? ((float) args.checkdouble(6)) : sx;
            //~ Log("print:"+s);
            if (mFont != null)
                mFont.print(s, x, y, r, sx, sy);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.printf( text, x, y, limit, align )
    /// NOTE: not related to c printf, rather wordwrap etc
    /// Draws formatted text, with word wrap and alignment. 
    t.set("printf", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            String s = args.checkjstring(1);
            float x = (float) args.checkdouble(2);
            float y = (float) args.checkdouble(3);
            float limit = (float) args.checkdouble(4);
            String align = (IsArgSet(args, 5)) ? args.checkjstring(5) : "left";
            //~ Log("printf:"+align+":"+s);
            if (mFont != null)
                mFont.printf(s, x, y, limit, LuanObjFont.Text2Align(align));
            return LuaValue.NONE;
        }
    });
    // todo : newImageFont, setfont,  print...
    /// font = love.graphics.newFont( filename, size ) 
    /// font = love.graphics.newFont( size )   (default font (Vera Sans))
    t.set("newFont", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            if (args.isstring(1)) {
                String filename = args.checkjstring(1);
                int iSize = IsArgSet(args, 2) ? args.checkint(2) : 12;
                try {
                    return LuaValue.userdataOf(new LuanObjFont(LuanGraphics.this, filename, iSize), vm.get_G().get(sMetaName_LuanFont));
                } catch (Exception e) {
                    vm.handleError(e);
                }
                return LuaValue.NONE;
            } else {
                int iSize = (IsArgSet(args, 1)) ? args.checkint(1) : 12;
                try {
                    return LuaValue.userdataOf(new LuanObjFont(LuanGraphics.this, iSize), vm.get_G().get(sMetaName_LuanFont));
                } catch (Exception e) {
                    vm.handleError(e);
                }
                return LuaValue.NONE;
            }
        }
    });
    /// font = love.graphics.newImageFont( image, glyphs )
    t.set("newImageFont", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            if (args.isstring(1)) {
                String filename = args.checkjstring(1);
                String glyphs = args.checkjstring(2);
                try {
                    return LuaValue.userdataOf(new LuanObjFont(LuanGraphics.this, filename, glyphs), vm.get_G().get(sMetaName_LuanFont));
                } catch (Exception e) {
                    vm.handleError(e);
                }
                return LuaValue.NONE;
            } else {
                LuanObjImage img = (LuanObjImage) args.checkuserdata(1, LuanObjImage.class);
                String glyphs = args.checkjstring(2);
                return LuaValue.userdataOf(new LuanObjFont(LuanGraphics.this, img, glyphs), vm.get_G().get(sMetaName_LuanFont));
            }
        }
    });
    /// love.graphics.setFont( font )
    t.set("setFont", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            mFont = IsArgSet(args, 1) ? (LuanObjFont) args.checkuserdata(1, LuanObjFont.class) : mDefaultFont;
            return LuaValue.NONE;
        }
    });
    // ***** ***** ***** ***** ***** rest
    /// img = love.graphics.newImage(sFileName)
    t.set("newImage", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            String s = args.checkjstring(1);
            try {
                return LuaValue.userdataOf(new LuanObjImage(LuanGraphics.this, s), vm.get_G().get(sMetaName_LuanImage));
            } catch (Exception e) {
                vm.handleError(e);
            }
            return LuaValue.NONE;
        }
    });
    /// quad = love.graphics.newQuad( x, y, width, height, sw, sh )
    t.set("newQuad", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            float x = (float) args.checkdouble(1);
            float y = (float) args.checkdouble(2);
            float w = (float) args.checkdouble(3);
            float h = (float) args.checkdouble(4);
            float sw = (float) args.checkdouble(5);
            float sh = (float) args.checkdouble(6);
            try {
                return LuaValue.userdataOf(new LuanObjQuad(LuanGraphics.this, x, y, w, h, sw, sh), vm.get_G().get(sMetaName_LuanQuad));
            } catch (Exception e) {
                vm.handleError(e);
            }
            return LuaValue.NONE;
        }
    });
    /// system = love.graphics.newParticleSystem( image, buffer )
    t.set("newParticleSystem", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            LuanObjImage img = (LuanObjImage) args.checkuserdata(1, LuanObjImage.class);
            int iBufferSize = args.checkint(2);
            try {
                return LuaValue.userdataOf(new LuanObjParticleSystem(LuanGraphics.this, img, iBufferSize), vm.get_G().get(sMetaName_LuanParticleSystem));
            } catch (Exception e) {
                vm.handleError(e);
            }
            return LuaValue.NONE;
        }
    });
    /// love.graphics.draw(drawable, x, y, r=0, sx=1, sy=1, ox=0, oy=0)
    t.set("draw", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            LuanObjDrawable drawable = (LuanObjDrawable) args.checkuserdata(1, LuanObjDrawable.class);
            float x = (float) args.checkdouble(2);
            float y = (float) args.checkdouble(3);
            float r = (IsArgSet(args, 4)) ? ((float) args.checkdouble(4)) : 0.0f;
            float sx = (IsArgSet(args, 5)) ? ((float) args.checkdouble(5)) : 1.0f;
            float sy = (IsArgSet(args, 6)) ? ((float) args.checkdouble(6)) : 1.0f;
            float ox = (IsArgSet(args, 7)) ? ((float) args.checkdouble(7)) : 0.0f;
            float oy = (IsArgSet(args, 8)) ? ((float) args.checkdouble(8)) : 0.0f;
            if (drawable.IsImage()) {
                LuanObjImage img = (LuanObjImage) drawable;
                DrawSprite(img.GetTextureID(), img.mWidth, img.mHeight, x, y, r, sx, sy, ox, oy);
            } else {
                drawable.RenderSelf(x, y, r, sx, sy, ox, oy);
            }
            return LuaValue.NONE;
        }
    });
    /// love.graphics.drawq( image, quad, x, y, r, sx, sy, ox, oy )
    t.set("drawq", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            LuanObjImage img = (LuanObjImage) args.checkuserdata(1, LuanObjImage.class);
            LuanObjQuad quad = (LuanObjQuad) args.checkuserdata(2, LuanObjQuad.class);
            float x = (float) args.checkdouble(3);
            float y = (float) args.checkdouble(4);
            float r = (IsArgSet(args, 5)) ? ((float) args.checkdouble(5)) : 0.0f;
            float sx = (IsArgSet(args, 6)) ? ((float) args.checkdouble(6)) : 1.0f;
            float sy = (IsArgSet(args, 7)) ? ((float) args.checkdouble(7)) : 1.0f;
            float ox = (IsArgSet(args, 8)) ? ((float) args.checkdouble(8)) : 0.0f;
            float oy = (IsArgSet(args, 9)) ? ((float) args.checkdouble(9)) : 0.0f;
            DrawSprite(img.GetTextureID(), quad, quad.w, quad.h, x, y, r, sx, sy, ox, oy);
            return LuaValue.NONE;
        }
    });
    /// success = love.graphics.setMode( width, height, fullscreen, vsync, fsaa )
    t.set("setMode", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            bResolutionOverrideActive = true;
            mfResolutionOverrideX = args.checkint(1);
            mfResolutionOverrideY = args.checkint(2);
            // TODO: idea : if w>h and natural w<h , flip 90� ?
            Log("love.graphics.setMode requested resolution = " + mfResolutionOverrideX + " x " + mfResolutionOverrideY);
            return LuaValue.TRUE;
        }
    });
    /// width = love.graphics.getWidth( )
    /// Gets the width of the window. 
    t.set("getWidth", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            float w = getScreenW();
            Log("love.graphics.getWidth = " + w);
            return LuaValue.valueOf(w);
        }
    });
    /// height = love.graphics.getHeight( )
    /// Gets the height of the window.
    t.set("getHeight", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            float h = getScreenH();
            Log("love.graphics.getHeight = " + h);
            return LuaValue.valueOf(h);
        }
    });
    // ***** ***** ***** ***** ***** global transforms / coordinate system
    /// love.graphics.scale( sx, sy )
    /// Scaling lasts until love.draw() exits. 
    t.set("scale", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            float sx = (float) args.checkdouble(1);
            float sy = (float) args.checkdouble(2);
            getGL().glScalef(sx, sy, 1);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.translate( dx, dy )
    /// Translates the coordinate system in two dimensions. 
    t.set("translate", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            float dx = (float) args.checkdouble(1);
            float dy = (float) args.checkdouble(2);
            getGL().glTranslatef(dx, dy, 1);
            return LuaValue.NONE;
        }
    });
    /// Rotates the coordinate system in two dimensions. 
    /// Calling this function affects all future drawing operations by rotating the coordinate system around the origin by the given amount of radians. This change lasts until love.draw() exits. 
    /// love.graphics.rotate( angle )
    t.set("rotate", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            float a = (float) args.checkdouble(1);
            getGL().glRotatef(LOVE_TODEG(a), 0, 0, 1);
            return LuaValue.NONE;
        }
    });
    /// love.graphics.reset( )
    /// Calling reset makes the current drawing color white, the current background color black, the window title empty and removes any scissor settings. It sets the BlendMode to alpha and ColorMode to modulate. 
    /// It also sets both the point and line drawing modes to smooth and their sizes to 1.0 . Finally, it removes any stipple settings. 
    t.set("reset", new VarArgFunction() {

        @Override
        public Varargs invoke(Varargs args) {
            setBackgroundColor(new LuanColor(0.0f, 0.0f, 0.0f, 1.0f));
            setForegroundColor(new LuanColor(1f, 1f, 1f, 1f));
            resetTransformMatrix(getGL());
            vm.NotImplemented("love.graphics.reset (lots of settings)");
            // TODO: not yet implemented
            return LuaValue.NONE;
        }
    });
    return t;
}

Example 4 with Buffer

use of org.luaj.vm2.Buffer in project LuaViewSDK by alibaba.

the class OsLib method date.

/**
	 * If the time argument is present, this is the time to be formatted 
	 * (see the os.time function for a description of this value). 
	 * Otherwise, date formats the current time.
	 * 
	 * Date returns the date as a string, 
	 * formatted according to the same rules as ANSII strftime, but without
	 * support for %g, %G, or %V.
	 * 
	 * When called without arguments, date returns a reasonable date and 
	 * time representation that depends on the host system and on the 
	 * current locale (that is, os.date() is equivalent to os.date("%c")).
	 *  
	 * @param format 
	 * @param time time since epoch, or -1 if not supplied
	 * @return a LString or a LTable containing date and time, 
	 * formatted according to the given string format.
	 */
public String date(String format, double time) {
    Calendar d = Calendar.getInstance();
    d.setTime(new Date((long) (time * 1000)));
    if (format.startsWith("!")) {
        time -= timeZoneOffset(d);
        d.setTime(new Date((long) (time * 1000)));
        format = format.substring(1);
    }
    byte[] fmt = format.getBytes();
    final int n = fmt.length;
    Buffer result = new Buffer(n);
    byte c;
    for (int i = 0; i < n; ) {
        switch(c = fmt[i++]) {
            case '\n':
                result.append("\n");
                break;
            default:
                result.append(c);
                break;
            case '%':
                if (i >= n)
                    break;
                switch(c = fmt[i++]) {
                    default:
                        LuaValue.argerror(1, "invalid conversion specifier '%" + c + "'");
                        break;
                    case '%':
                        result.append((byte) '%');
                        break;
                    case 'a':
                        result.append(WeekdayNameAbbrev[d.get(Calendar.DAY_OF_WEEK) - 1]);
                        break;
                    case 'A':
                        result.append(WeekdayName[d.get(Calendar.DAY_OF_WEEK) - 1]);
                        break;
                    case 'b':
                        result.append(MonthNameAbbrev[d.get(Calendar.MONTH)]);
                        break;
                    case 'B':
                        result.append(MonthName[d.get(Calendar.MONTH)]);
                        break;
                    case 'c':
                        result.append(date("%a %b %d %H:%M:%S %Y", time));
                        break;
                    case 'd':
                        result.append(String.valueOf(100 + d.get(Calendar.DAY_OF_MONTH)).substring(1));
                        break;
                    case 'H':
                        result.append(String.valueOf(100 + d.get(Calendar.HOUR_OF_DAY)).substring(1));
                        break;
                    case 'I':
                        result.append(String.valueOf(100 + (d.get(Calendar.HOUR_OF_DAY) % 12)).substring(1));
                        break;
                    case 'j':
                        {
                            // day of year.
                            Calendar y0 = beginningOfYear(d);
                            int dayOfYear = (int) ((d.getTime().getTime() - y0.getTime().getTime()) / (24 * 3600L * 1000L));
                            result.append(String.valueOf(1001 + dayOfYear).substring(1));
                            break;
                        }
                    case 'm':
                        result.append(String.valueOf(101 + d.get(Calendar.MONTH)).substring(1));
                        break;
                    case 'M':
                        result.append(String.valueOf(100 + d.get(Calendar.MINUTE)).substring(1));
                        break;
                    case 'p':
                        result.append(d.get(Calendar.HOUR_OF_DAY) < 12 ? "AM" : "PM");
                        break;
                    case 'S':
                        result.append(String.valueOf(100 + d.get(Calendar.SECOND)).substring(1));
                        break;
                    case 'U':
                        result.append(String.valueOf(weekNumber(d, 0)));
                        break;
                    case 'w':
                        result.append(String.valueOf((d.get(Calendar.DAY_OF_WEEK) + 6) % 7));
                        break;
                    case 'W':
                        result.append(String.valueOf(weekNumber(d, 1)));
                        break;
                    case 'x':
                        result.append(date("%m/%d/%y", time));
                        break;
                    case 'X':
                        result.append(date("%H:%M:%S", time));
                        break;
                    case 'y':
                        result.append(String.valueOf(d.get(Calendar.YEAR)).substring(2));
                        break;
                    case 'Y':
                        result.append(String.valueOf(d.get(Calendar.YEAR)));
                        break;
                    case 'z':
                        {
                            final int tzo = timeZoneOffset(d) / 60;
                            final int a = Math.abs(tzo);
                            final String h = String.valueOf(100 + a / 60).substring(1);
                            final String m = String.valueOf(100 + a % 60).substring(1);
                            result.append((tzo >= 0 ? "+" : "-") + h + m);
                            break;
                        }
                }
        }
    }
    return result.tojstring();
}

Example 5 with Buffer

use of org.luaj.vm2.Buffer in project LuaViewSDK by alibaba.

the class StringLib method gsub.

/**
     * string.gsub (s, pattern, repl [, n])
     * Returns a copy of s in which all (or the first n, if given) occurrences of the
     * pattern have been replaced by a replacement string specified by repl, which
     * may be a string, a table, or a function. gsub also returns, as its second value,
     * the total number of matches that occurred.
     *
     * If repl is a string, then its value is used for replacement.
     * The character % works as an escape character: any sequence in repl of the form %n,
     * with n between 1 and 9, stands for the value of the n-th captured substring (see below).
     * The sequence %0 stands for the whole match. The sequence %% stands for a single %.
     *
     * If repl is a table, then the table is queried for every match, using the first capture
     * as the key; if the pattern specifies no captures, then the whole match is used as the key.
     *
     * If repl is a function, then this function is called every time a match occurs,
     * with all captured substrings passed as arguments, in order; if the pattern specifies
     * no captures, then the whole match is passed as a sole argument.
     *
     * If the value returned by the table query or by the function call is a string or a number,
     * then it is used as the replacement string; otherwise, if it is false or nil,
     * then there is no replacement (that is, the original match is kept in the string).
     *
     * Here are some examples:
     * 	     x = string.gsub("hello world", "(%w+)", "%1 %1")
     * 	     --> x="hello hello world world"
     *
     *	     x = string.gsub("hello world", "%w+", "%0 %0", 1)
     *	     --> x="hello hello world"
     *
     *	     x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
     *	     --> x="world hello Lua from"
     *
     *	     x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
     *	     --> x="home = /home/roberto, user = roberto"
     *
     *	     x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
     *	           return loadstring(s)()
     *       end)
     *	     --> x="4+5 = 9"
     *
     *	     local t = {name="lua", version="5.1"}
     *	     x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
     *	     --> x="lua-5.1.tar.gz"
     */
static Varargs gsub(Varargs args) {
    LuaString src = args.checkstring(1);
    final int srclen = src.length();
    LuaString p = args.checkstring(2);
    LuaValue repl = args.arg(3);
    int max_s = args.optint(4, srclen + 1);
    final boolean anchor = p.length() > 0 && p.charAt(0) == '^';
    Buffer lbuf = new Buffer(srclen);
    MatchState ms = new MatchState(args, src, p);
    int soffset = 0;
    int n = 0;
    while (n < max_s) {
        ms.reset();
        int res = ms.match(soffset, anchor ? 1 : 0);
        if (res != -1) {
            n++;
            ms.add_value(lbuf, soffset, res, repl);
        }
        if (res != -1 && res > soffset)
            soffset = res;
        else if (soffset < srclen)
            lbuf.append((byte) src.luaByte(soffset++));
        else
            break;
        if (anchor)
            break;
    }
    lbuf.append(src.substring(soffset, srclen));
    return varargsOf(lbuf.tostring(), valueOf(n));
}