Example usage for org.lwjgl.opengl GL11 glPopMatrix

Introduction

In this page you can find the example usage for org.lwjgl.opengl GL11 glPopMatrix.

Prototype

public static native void glPopMatrix();

Source Link

Document

Pops the top entry off the current matrix stack, replacing the current matrix with the matrix that was the second entry in the stack.

Usage

From source file:chessMod.client.ChessModDrawBlockHighlightHandler.java

License:LGPL

public static void highlightTile(EntityPlayer player, double x, double y, double z, float partialTicks) {

    x += 0.5D;/*from w ww  .j  a va 2 s. co  m*/
    y += 0.5D;
    z += 0.5D;
    double iPX = player.prevPosX + (player.posX - player.prevPosX) * partialTicks;
    double iPY = player.prevPosY + (player.posY - player.prevPosY) * partialTicks;
    double iPZ = player.prevPosZ + (player.posZ - player.prevPosZ) * partialTicks;

    float xScale = 1.0F;
    float yScale = 1;
    float zScale = 1.0F;
    float xShift = 0.0F;
    float yShift = 0.01F;
    float zShift = 0.0F;

    GL11.glDepthMask(false);
    GL11.glDisable(GL11.GL_CULL_FACE);

    for (int i = 4; i < 5; i++) {
        ForgeDirection forgeDir = ForgeDirection.getOrientation(i);
        int zCorrection = i == 2 ? -1 : 1;
        GL11.glPushMatrix();
        GL11.glTranslated(-iPX + x + xShift, -iPY + y + yShift, -iPZ + z + zShift);
        GL11.glScalef(1F * xScale, 1F * yScale, 1F * zScale);
        GL11.glRotatef(90, forgeDir.offsetX, forgeDir.offsetY, forgeDir.offsetZ);
        GL11.glTranslated(0, 0, 0.5f * zCorrection);
        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
        drawQuad(-0.5F, -0.5F, 1F, 1F, 0F);
        GL11.glPopMatrix();
    }

    GL11.glEnable(GL11.GL_CULL_FACE);
    GL11.glDepthMask(true);
}

---

From source file:cn.academy.ability.client.ui.CPBar.java

License:GNU General Public License

private void initEvents() {
    listen(FrameEvent.class, (w, e) -> {
        EntityPlayer player = Minecraft.getMinecraft().thePlayer;
        CPData cpData = CPData.get(player);
        AbilityData aData = AbilityData.get(player);
        if (!aData.hasCategory())
            return;

        Category c = aData.getCategory();
        overlayTexture = c.getOverlayIcon();

        boolean active = cpData.isActivated();

        // Calculate alpha
        long time = GameTimer.getTime();
        if (!lastFrameActive && active) {
            showTime = time;/*from   w  w w .  j a  v a2s. c  o m*/
        }

        // Takes account of interference
        long deltaTime = Math.min(100L, time - lastDrawTime);

        final long BLENDIN_TIME = 200L;
        mAlpha = (time - showTime < BLENDIN_TIME) ? (float) (time - showTime) / BLENDIN_TIME
                : (active ? 1.0f : Math.max(0.0f, 1 - (time - lastDrawTime) / 200.0f));

        boolean interf = cpData.isInterfering();
        boolean overloadRecovering = cpData.isOverloadRecovering();

        if (interf) {
            OffsetKeyframe frame = int_get();
            GL11.glTranslated(frame.direction.x, frame.direction.y, 0);
            long timeInput = GameTimer.getAbsTime() % maxtime;
            timeInput = (timeInput / 10) * 10; // Lower the precision to produce 'jagged' effect
            mAlpha *= alphaCurve.valueAt(timeInput);
        }

        GL11.glPushMatrix(); // PUSH 1

        float poverload = mAlpha > 0 ? cpData.getOverload() / cpData.getMaxOverload() : 0;
        bufferedOverload = balance(bufferedOverload, poverload, deltaTime * 1E-3f * O_BALANCE_SPEED);

        float pcp = mAlpha > 0 ? cpData.getCP() / cpData.getMaxCP() : 0;
        bufferedCP = balance(bufferedCP, pcp, deltaTime * 1E-3f * CP_BALANCE_SPEED);

        if (mAlpha > 0) {
            /* Draw CPBar */ {
                if (!cpData.isOverloaded()) {
                    drawNormal(bufferedOverload);
                } else {
                    drawOverload(bufferedOverload);
                }

                if (chProvider != null && !chProvider.alive())
                    chProvider = null;

                float estmCons = getConsumptionHint();
                boolean low = interf || overloadRecovering;

                if (estmCons != 0) {
                    float ncp = Math.max(0, cpData.getCP() - estmCons);

                    float oldAlpha = mAlpha;
                    mAlpha *= 0.2f + 0.1f * (1 + Math.sin(time / 80.0f));

                    drawCPBar(pcp, low);

                    mAlpha = oldAlpha;

                    drawCPBar(ncp / cpData.getMaxCP(), low);
                } else {
                    drawCPBar(bufferedCP, low);
                }
            }

            /* Draw Preset Hint */ {
                final long preset_wait = 2000L;
                if (time - presetChangeTime < preset_wait)
                    drawPresetHint((double) (time - presetChangeTime) / preset_wait, time - lastPresetTime);
            }

            // Draw data
            {
                float alpha;
                long dt = lastShowValueChange == 0 ? Long.MAX_VALUE : time - lastShowValueChange;

                if (cpData.isOverloaded()) {
                    alpha = 0.0f;
                } else if (showingNumbers) {
                    alpha = MathUtils.clampf(0, 1, (dt - 200) / 400f); // Delay display by 200ms for visual pleasure
                } else if (dt < 300f) {
                    alpha = 1 - dt / 300f;
                } else {
                    alpha = 0.0f;
                }

                if (alpha > 0) {
                    final double x0 = 110;

                    IFont font = Resources.font();
                    FontOption option = new FontOption(40);
                    option.color.a = 0.6f * mAlpha * alpha;

                    String str10 = "CP ";
                    String str11 = String.format("%.0f", cpData.getCP());
                    String str12 = String.format("/%.0f", cpData.getMaxCP());

                    String str20 = "OL ";
                    String str21 = String.format("%.0f", cpData.getOverload());
                    String str22 = String.format("/%.0f", cpData.getMaxOverload());

                    double len10 = font.getTextWidth(str10, option), len11 = font.getTextWidth(str11, option),
                            len20 = font.getTextWidth(str20, option), len21 = font.getTextWidth(str21, option);

                    double len0 = Math.max(len10, len20);
                    double len1 = len0 + Math.max(len11, len21);

                    font.draw(str10, x0, 55, option);
                    font.draw(str12, x0 + len1, 55, option);
                    font.draw(str20, x0, 85, option);
                    font.draw(str22, x0 + len1, 85, option);

                    option.align = FontAlign.RIGHT;
                    font.draw(str11, x0 + len1, 55, option);
                    font.draw(str21, x0 + len1, 85, option);
                }
            }

            drawActivateKeyHint();
        }

        if (active) {
            lastDrawTime = time;
        }

        lastFrameActive = active;

        GL11.glColor4d(1, 1, 1, 1);
        GL11.glPopMatrix(); // Pop 1
    });
}

---

From source file:cn.academy.ability.client.ui.KeyHintUI.java

License:GNU General Public License

private void addDrawing() {
    listen(FrameEvent.class, (w, e) -> {
        EntityPlayer player = Minecraft.getMinecraft().thePlayer;

        CPData cpData = CPData.get(player);

        canUseAbility = cpData.canUseAbility();

        long time = GameTimer.getTime();
        if (time - lastFrameTime > 300L) {
            showTime = time;//from  www  .j a va2s.c o m
        }

        if ((time - showTime) < 300L) {
            mAlpha = (time - showTime) / 300.0;
        } else {
            mAlpha = 1.0;
        }

        sinAlpha = 0.6f + (1 + MathHelper.sin((time % 100000) / 50.0f)) * 0.2f;

        if (cpData.isActivated()) {
            ClientRuntime rt = ClientRuntime.instance();
            CooldownData cd = CooldownData.of(rt.getEntity());

            Multimap<String, DelegateNode> map = rt.getDelegateRawData();
            List<String> groups = new ArrayList<>(map.keySet());
            groups.sort((s1, s2) -> {
                if (s1.equals(ClientRuntime.DEFAULT_GROUP))
                    return -1;
                else if (s2.equals(ClientRuntime.DEFAULT_GROUP))
                    return 1;
                else
                    return s1.compareTo(s2);
            });

            int availIdx = 0;
            for (int i = 0; i < groups.size(); ++i) {
                Collection<DelegateNode> nodes = map.get(groups.get(i));
                if (!nodes.isEmpty()) {
                    final double x = -200 - availIdx * 200;
                    double y = 0;
                    for (DelegateNode node : nodes) {
                        GL11.glPushMatrix();
                        GL11.glTranslated(x, y, 0);
                        drawSingle(node.keyID, node.delegate,
                                cd.getSub(node.delegate.getSkill(), node.delegate.getIdentifier()));
                        GL11.glPopMatrix();
                        y += 92;
                    }
                    availIdx++;
                }
            }
        }

        lastFrameTime = time;
        GL11.glColor4d(1, 1, 1, 1);
    });
}

---

From source file:cn.academy.ability.electro.client.render.skill.ChargePlaneEffect.java

License:Open Source License

@SideOnly(Side.CLIENT)
@Override/*from  w  w  w . java2  s  . com*/
public void renderHud(EntityPlayer player, ScaledResolution sr, long time) {
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_ALPHA_TEST);
    GL11.glDepthMask(false);
    //GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    GL11.glPushMatrix();
    {
        GL11.glColor4d(1, 1, 1, 0.4);
        double w = sr.getScaledWidth_double(), h = sr.getScaledHeight_double();
        if (lct == 0 || time - lct > 200) {
            lct = time;
            seq.rebuild();
        }
        for (int i = 0; i < 4; ++i) {
            RenderUtils.loadTexture(TEXS[seq.get(i)]);
            HudUtils.drawRect(w * pts[i][0], h * pts[i][1], sizes[i] * w, sizes[i] * w);
        }
        RenderUtils.bindIdentity();
    }
    GL11.glPopMatrix();
    GL11.glDepthMask(true);
    GL11.glDisable(GL11.GL_BLEND);
    GL11.glEnable(GL11.GL_ALPHA_TEST);
}

---

From source file:cn.academy.ability.electro.client.render.skill.RailgunPlaneEffect.java

License:Open Source License

@SideOnly(Side.CLIENT)
@Override//w  w  w .jav a 2  s  . co m
public void renderHandEffect(EntityPlayer player, HandRenderType type, long dt) {
    if (type == HandRenderType.EQUIPPED)
        return;
    if (dt < DELAY)
        return;
    dt -= DELAY;

    double tz = dt * dt / 3e4;
    double TRANS_TIME = ANIM_LEN * 0.2;
    double alpha = (dt < TRANS_TIME ? dt / TRANS_TIME
            : (dt > ANIM_LEN - TRANS_TIME ? (ANIM_LEN - dt) / TRANS_TIME : 1));

    //Draw a screen-filling blackout
    GL11.glDisable(GL11.GL_TEXTURE_2D);
    GL11.glDisable(GL11.GL_CULL_FACE);

    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glPushMatrix();
    GL11.glLoadIdentity();
    GLU.gluOrtho2D(0, 255, 0, 255);

    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glPushMatrix();
    GL11.glDepthMask(false);
    GL11.glLoadIdentity();
    {
        GL11.glTranslated(0, 0, 0);
        GL11.glColor4d(0, 0, 0, 0.2 * alpha);
        HudUtils.setZLevel(1);
        HudUtils.drawModalRect(0, 0, 255, 255);
        HudUtils.setZLevel(-90);
    }
    GL11.glDepthMask(true);

    GL11.glMatrixMode(GL11.GL_MODELVIEW);
    GL11.glPopMatrix();

    GL11.glMatrixMode(GL11.GL_PROJECTION);
    GL11.glPopMatrix();

    GL11.glEnable(GL11.GL_TEXTURE_2D);
    GL11.glEnable(GL11.GL_CULL_FACE);
    GL11.glMatrixMode(GL11.GL_MODELVIEW); //Restore the matrix

    //Draw the real effect

    GL11.glColor4d(1, 1, 1, alpha * 0.6);
    GL11.glEnable(GL11.GL_ALPHA_TEST);
    GL11.glAlphaFunc(GL11.GL_GREATER, 0.0f);
    GL11.glPushMatrix();
    {
        GL11.glTranslated(-.4, 0.85 + tz * 0.37, tz);
        GL11.glRotated(-20.4, 1, 0, 0);

        drawSingleSide(7);

        //         GL11.glPushMatrix(); {
        //            GL11.glTranslated(-2.3, 0, 0);
        //            drawSingleSide(7);
        //         } GL11.glPopMatrix();
    }
    GL11.glPopMatrix();

    GL11.glDisable(GL11.GL_ALPHA_TEST);
}

---

From source file:cn.academy.ability.electro.client.render.skill.RailgunPlaneEffect.java

License:Open Source License

private void drawSingleSide(int n) {
    //line.draw();
    for (int i = n; i >= 0; --i) {
        double z = (4 + 6 * i * i) / 12d;
        GL11.glPushMatrix();/*from ww w.ja v a 2s.co m*/
        GL11.glTranslated(0, 0, -z);
        circle.draw();
        GL11.glPopMatrix();
    }
}

---

From source file:cn.academy.ability.electro.client.render.skill.SRSmallCharge.java

License:Open Source License

@Override
public void draw() {
    GL11.glDisable(GL11.GL_CULL_FACE);//ww  w .j av  a 2 s. c o  m
    GL11.glDepthMask(false);
    GL11.glPushMatrix();
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    GL11.glColor4d(1, 1, 1, 0.7);

    GL11.glTranslated(0, 0.9, 0.2);
    GL11.glRotated(120, 1, 0, 0);
    GL11.glScaled(0.5, 0.5, 0.5);
    //RenderUtils.drawCube(1, 1, 2);
    for (ArcObject arc : arcs) {
        arc.draw();
    }

    GL11.glPopMatrix();
    GL11.glDepthMask(true);
    GL11.glEnable(GL11.GL_CULL_FACE);
}

---

From source file:cn.academy.ability.teleport.client.render.entity.MarkRender.java

License:Open Source License

@Override
public void doRender(Entity ent, double x, double y, double z, float var8, float var9) {
    EntityTPMarking mark = (EntityTPMarking) ent;
    int texID = (int) ((mark.ticksExisted / 2.5) % tex.length);

    GL11.glEnable(GL11.GL_BLEND);/* w  w  w  . j a va 2 s  .  c o m*/
    GL11.glDisable(GL11.GL_LIGHTING);
    GL11.glDisable(GL11.GL_CULL_FACE);
    GL11.glDisable(GL11.GL_DEPTH_TEST);
    GL11.glColor4d(1, 1, 1, 1);
    GL11.glPushMatrix();
    {
        GL11.glTranslated(x, y, z);

        GL11.glRotated(-mark.rotationYaw, 0, 1, 0);
        GL11.glScaled(-1, -1, 1);
        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240f, 240f);
        Tessellator.instance.setBrightness(15728880);
        RenderUtils.loadTexture(tex[texID]);
        model.draw();
    }
    GL11.glPopMatrix();
    GL11.glEnable(GL11.GL_DEPTH_TEST);
    GL11.glEnable(GL11.GL_LIGHTING);
    GL11.glEnable(GL11.GL_CULL_FACE);
}

---

From source file:cn.academy.core.client.ACRenderingHelper.java

License:GNU General Public License

/**
 * Draws a circular progress bar at (0, 0) with radius 1
 *///  w ww.j  av a2  s .co  m
public static void drawCircularProgbar(ResourceLocation texture, double progress) {

    progress *= 360;
    if (progress > 360)
        progress %= 360;

    Tessellator t = Tessellator.instance;

    GL11.glPushMatrix();
    RenderUtils.loadTexture(texture);
    for (int i = 0; i < 4; ++i) {
        double angle = Math.min(90, progress - 90 * i);
        if (angle <= 0)
            break;
        double u1, v1;
        t.startDrawing(GL11.GL_TRIANGLES);

        if (angle <= 45) {
            u1 = Math.tan(MathUtils.toRadians(angle));
            v1 = 0;
        } else {
            u1 = 1;
            v1 = 0;

            double x = Math.tan(MathUtils.toRadians(90 - angle));
            t.addVertexWithUV(1, -1, 0, 1, 0);
            t.addVertexWithUV(0, 0, 0, 0, 1);
            t.addVertexWithUV(1, -x, 0, 1, 1 - x);
        }

        t.addVertexWithUV(0, -1, 0, 0, 0);
        t.addVertexWithUV(0, 0, 0, 0, 1);
        t.addVertexWithUV(u1, -1 - v1, 0, u1, v1);
        t.draw();

        GL11.glRotated(90, 0, 0, 1);
    }
    GL11.glPopMatrix();
    GL11.glEnable(GL11.GL_TEXTURE_2D);
}

---

From source file:cn.academy.core.client.ACRenderingHelper.java

License:GNU General Public License

private static void dirQuad(double x0, double y0, double x1, double y1, float width) {
    float hw = width / 2;
    Tessellator t = Tessellator.instance;
    double dy = y1 - y0, dx = x1 - x0, len = Math.sqrt(dy * dy + dx * dx);
    double theta = MathUtils.toDegrees(Math.atan2(dy, dx));

    GL11.glPushMatrix();//from   w  ww .  j  a  v a 2  s . com
    GL11.glTranslated(x0, y0, 0);
    GL11.glRotated(theta, 0, 0, 1);
    t.startDrawingQuads();
    t.addVertexWithUV(0, -hw, 0, 0, 0);
    t.addVertexWithUV(0, hw, 0, 0, 1);
    t.addVertexWithUV(len, hw, 0, 1, 1);
    t.addVertexWithUV(len, -hw, 0, 1, 0);
    t.draw();
    GL11.glPopMatrix();
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »