Example usage for org.lwjgl.opengl GL11 glScalef

Introduction

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

Prototype

public static native void glScalef(@NativeType("GLfloat") float x, @NativeType("GLfloat") float y,
        @NativeType("GLfloat") float z);

Source Link

Document

Manipulates the current matrix with a general scaling matrix along the x-, y- and z- axes.

Usage

From source file:com.pahimar.ee3.client.renderer.item.ItemGlassBellRenderer.java

License:LGPL

private void renderGlassBell(float x, float y, float z, float scale) {

    GL11.glPushMatrix();/* w  w w  . ja va 2 s .  c  om*/
    GL11.glDisable(GL11.GL_LIGHTING);

    // Scale, Translate, Rotate
    GL11.glScalef(scale, scale, scale);
    GL11.glTranslatef(x, y, z);
    GL11.glRotatef(-90F, 1F, 0, 0);

    // Bind texture
    FMLClientHandler.instance().getClient().renderEngine.bindTexture(Textures.MODEL_GLASS_BELL);

    // Render
    modelGlassBell.render();

    GL11.glEnable(GL11.GL_LIGHTING);
    GL11.glPopMatrix();
}

---

From source file:com.pahimar.ee3.client.renderer.RenderUtils.java

License:LGPL

public static void renderRotatingBlockIntoGUI(FontRenderer fontRenderer, RenderEngine renderEngine,
        ItemStack stack, int x, int y, float zLevel, float scale) {

    RenderBlocks renderBlocks = new RenderBlocks();

    Block block = Block.blocksList[stack.itemID];
    renderEngine.bindTexture(Textures.VANILLA_BLOCK_TEXTURE_SHEET);
    GL11.glPushMatrix();//from  w w w  . j a va 2s  .co  m
    GL11.glTranslatef(x - 2, y + 3, -3.0F + zLevel);
    GL11.glScalef(10.0F, 10.0F, 10.0F);
    GL11.glTranslatef(1.0F, 0.5F, 1.0F);
    GL11.glScalef(1.0F * scale, 1.0F * scale, -1.0F);
    GL11.glRotatef(210.0F, 1.0F, 0.0F, 0.0F);
    GL11.glRotatef(0F + 1 * rotationAngle, 0.0F, 1.0F, 0.0F);
    rotationAngle = (rotationAngle + 1) % 360;

    int var10 = Item.itemsList[stack.itemID].getColorFromItemStack(stack, 0);
    float var16 = (var10 >> 16 & 255) / 255.0F;
    float var12 = (var10 >> 8 & 255) / 255.0F;
    float var13 = (var10 & 255) / 255.0F;

    GL11.glColor4f(var16, var12, var13, 1.0F);

    GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F);
    renderBlocks.useInventoryTint = true;
    renderBlocks.renderBlockAsItem(block, stack.getItemDamage(), 1.0F);
    renderBlocks.useInventoryTint = true;
    GL11.glPopMatrix();
}

---

From source file:com.pahimar.ee3.client.renderer.tileentity.TileEntityAlchemicalChestRenderer.java

License:LGPL

@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float tick) {

    if (tileEntity instanceof TileAlchemicalChest) {

        TileAlchemicalChest tileAlchemicalChest = (TileAlchemicalChest) tileEntity;
        ForgeDirection direction = null;

        if (tileAlchemicalChest.getWorldObj() != null) {
            direction = ForgeDirection.getOrientation(tileAlchemicalChest.getBlockMetadata());
        }/*from  w w w  . j av  a 2  s .  co m*/

        FMLClientHandler.instance().getClient().renderEngine.bindTexture(Textures.MODEL_ALCHEMICAL_CHEST);
        GL11.glPushMatrix();
        GL11.glEnable(GL12.GL_RESCALE_NORMAL);
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x, (float) y + 1.0F, (float) z + 1.0F);
        GL11.glScalef(1.0F, -1.0F, -1.0F);
        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
        short angle = 0;

        if (direction != null) {
            if (direction == ForgeDirection.NORTH) {
                angle = 180;
            } else if (direction == ForgeDirection.SOUTH) {
                angle = 0;
            } else if (direction == ForgeDirection.WEST) {
                angle = 90;
            } else if (direction == ForgeDirection.EAST) {
                angle = -90;
            }
        }

        GL11.glRotatef(angle, 0.0F, 1.0F, 0.0F);
        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
        float adjustedLidAngle = tileAlchemicalChest.prevLidAngle
                + (tileAlchemicalChest.lidAngle - tileAlchemicalChest.prevLidAngle) * tick;
        adjustedLidAngle = 1.0F - adjustedLidAngle;
        adjustedLidAngle = 1.0F - adjustedLidAngle * adjustedLidAngle * adjustedLidAngle;
        modelChest.chestLid.rotateAngleX = -(adjustedLidAngle * (float) Math.PI / 2.0F);
        modelChest.renderAll();
        GL11.glDisable(GL12.GL_RESCALE_NORMAL);
        GL11.glPopMatrix();
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    }
}

---

From source file:com.pahimar.ee3.client.renderer.tileentity.TileEntityAlchemyTableRenderer.java

License:LGPL

@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float tick) {

    if (tileEntity instanceof TileAlchemyTable) {
        // TODO Use the TileAlchemyTable to determine what circle to project on the server of the table
        TileAlchemyTable tileAlchemyTable = (TileAlchemyTable) tileEntity;

        GL11.glPushMatrix();/* w w w  .  ja  v  a  2  s.  c  om*/
        GL11.glDisable(GL11.GL_LIGHTING);

        // Scale, Translate, Rotate
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + 0.0F, (float) y + 0.0F, (float) z + 1.0F);

        // Bind texture
        FMLClientHandler.instance().getClient().renderEngine.bindTexture(Textures.MODEL_ALCHEMY_TABLE);

        // Render
        modelAlchemyTable.render();

        GL11.glEnable(GL11.GL_LIGHTING);
        GL11.glPopMatrix();
    }
}

---

From source file:com.pahimar.ee3.client.renderer.tileentity.TileEntityAludelRenderer.java

License:LGPL

@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float tick) {

    if (tileEntity instanceof TileAludel) {

        TileAludel tileAludel = (TileAludel) tileEntity;

        GL11.glPushMatrix();/*from  w  w w  . jav a2s .c o m*/
        GL11.glDisable(GL11.GL_LIGHTING);

        // Scale, Translate, Rotate
        scaleTranslateRotate(x, y, z, tileAludel.getOrientation());

        // Bind texture
        FMLClientHandler.instance().getClient().renderEngine.bindTexture(Textures.MODEL_ALUDEL);

        // Render
        modelAludel.render();

        GL11.glPopMatrix();

        /**
         * Render the ghost item inside of the Aludel, slowly spinning
         */
        GL11.glPushMatrix();

        TileEntity tileGlassBell = tileAludel.worldObj.getBlockTileEntity(tileAludel.xCoord,
                tileAludel.yCoord + 1, tileAludel.zCoord);

        if (tileGlassBell instanceof TileGlassBell) {
            if (tileAludel.getStackInSlot(TileAludel.INPUT_INVENTORY_INDEX) != null) {

                float scaleFactor = getGhostItemScaleFactor(
                        tileAludel.getStackInSlot(TileAludel.INPUT_INVENTORY_INDEX));
                float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);

                EntityItem ghostEntityItem = new EntityItem(tileAludel.worldObj);
                ghostEntityItem.hoverStart = 0.0F;
                ghostEntityItem.setEntityItemStack(tileAludel.getStackInSlot(TileAludel.INPUT_INVENTORY_INDEX));

                GL11.glTranslatef((float) x + 0.5F, (float) y + 1.25F, (float) z + 0.5F);
                GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
                GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);

                customRenderItem.doRenderItem(ghostEntityItem, 0, 0, 0, 0, 0);
            }
        }

        GL11.glPopMatrix();

        GL11.glEnable(GL11.GL_LIGHTING);
    }
}

---

From source file:com.pahimar.ee3.client.renderer.tileentity.TileEntityCalcinatorRenderer.java

License:LGPL

@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float tick) {

    if (tileEntity instanceof TileCalcinator) {
        TileCalcinator tileCalcinator = (TileCalcinator) tileEntity;

        GL11.glPushMatrix();//w  w  w .  j  ava  2  s.  c o  m
        GL11.glDisable(GL11.GL_LIGHTING);

        // Scale, Translate, Rotate
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + 0.5F, (float) y + 0.0F, (float) z + 1.2F);
        GL11.glRotatef(45F, 0F, 1F, 0F);
        GL11.glRotatef(-90F, 1F, 0F, 0F);

        // Bind texture
        FMLClientHandler.instance().getClient().renderEngine.bindTexture(Textures.MODEL_CALCINATOR);

        // Render
        modelCalcinator.renderPart("Calcinator");

        if (tileCalcinator.getStackInSlot(TileCalcinator.OUTPUT_INVENTORY_INDEX) != null) {
            modelCalcinator.renderPart("Dust");
        }

        GL11.glEnable(GL11.GL_LIGHTING);
        GL11.glPopMatrix();
    }
}

---

From source file:com.pahimar.ee3.client.renderer.tileentity.TileEntityEnergyCondenserRenderer.java

License:LGPL

@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float tick) {

    if (tileEntity instanceof TileEnergyCondenser) {

        TileEnergyCondenser tileEnergyCondenser = (TileEnergyCondenser) tileEntity;
        ForgeDirection direction = null;

        if (tileEnergyCondenser.getWorldObj() != null) {
            direction = ForgeDirection.getOrientation(tileEnergyCondenser.getBlockMetadata());
        }/*from www .  java  2  s  .c  o  m*/

        FMLClientHandler.instance().getClient().renderEngine.bindTexture(Textures.MODEL_ENERGY_CONDENSER);
        GL11.glPushMatrix();
        GL11.glEnable(GL12.GL_RESCALE_NORMAL);
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x, (float) y + 1.0F, (float) z + 1.0F);
        GL11.glScalef(1.0F, -1.0F, -1.0F);
        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
        short angle = 0;

        if (direction != null) {
            if (direction == ForgeDirection.NORTH) {
                angle = 180;
            } else if (direction == ForgeDirection.SOUTH) {
                angle = 0;
            } else if (direction == ForgeDirection.WEST) {
                angle = 90;
            } else if (direction == ForgeDirection.EAST) {
                angle = -90;
            }
        }

        GL11.glRotatef(angle, 0.0F, 1.0F, 0.0F);
        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
        float adjustedLidAngle = tileEnergyCondenser.prevLidAngle
                + (tileEnergyCondenser.lidAngle - tileEnergyCondenser.prevLidAngle) * tick;
        adjustedLidAngle = 1.0F - adjustedLidAngle;
        adjustedLidAngle = 1.0F - adjustedLidAngle * adjustedLidAngle * adjustedLidAngle;
        modelChest.chestLid.rotateAngleX = -(adjustedLidAngle * (float) Math.PI / 2.0F);
        modelChest.renderAll();
        GL11.glDisable(GL12.GL_RESCALE_NORMAL);
        GL11.glPopMatrix();
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    }
}

---

From source file:com.pahimar.ee3.client.renderer.tileentity.TileEntityGlassBellRenderer.java

License:LGPL

@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float tick) {

    if (tileEntity instanceof TileGlassBell) {
        TileGlassBell tileGlassBell = (TileGlassBell) tileEntity;

        GL11.glDisable(GL11.GL_LIGHTING);
        GL11.glDisable(GL11.GL_CULL_FACE);

        /**//from   w  ww  .j a v a  2  s . co m
         * Render the Glass Bell
         */
        GL11.glPushMatrix();

        // Scale, Translate, Rotate
        renderGlassBellByOrientation(x, y, z, tileGlassBell.getOrientation());

        // Bind texture
        FMLClientHandler.instance().getClient().renderEngine.bindTexture(Textures.MODEL_GLASS_BELL);

        modelGlassBell.render();

        GL11.glPopMatrix();

        /**
         * Render the ghost item inside of the Glass Bell, slowly spinning
         */
        GL11.glPushMatrix();

        if (tileGlassBell.getStackInSlot(TileGlassBell.DISPLAY_SLOT_INVENTORY_INDEX) != null) {

            float scaleFactor = getGhostItemScaleFactor(
                    tileGlassBell.getStackInSlot(TileGlassBell.DISPLAY_SLOT_INVENTORY_INDEX));
            float rotationAngle = (float) (720.0 * (System.currentTimeMillis() & 0x3FFFL) / 0x3FFFL);

            EntityItem ghostEntityItem = new EntityItem(tileGlassBell.worldObj);
            ghostEntityItem.hoverStart = 0.0F;
            ghostEntityItem.setEntityItemStack(
                    tileGlassBell.getStackInSlot(TileGlassBell.DISPLAY_SLOT_INVENTORY_INDEX));

            translateGhostItemByOrientation(ghostEntityItem.getEntityItem(), x, y, z,
                    tileGlassBell.getOrientation());
            GL11.glScalef(scaleFactor, scaleFactor, scaleFactor);
            GL11.glRotatef(rotationAngle, 0.0F, 1.0F, 0.0F);

            customRenderItem.doRenderItem(ghostEntityItem, 0, 0, 0, 0, 0);
        }

        GL11.glPopMatrix();

        GL11.glEnable(GL11.GL_CULL_FACE);
        GL11.glEnable(GL11.GL_LIGHTING);
    }
}

---

From source file:com.pahimar.ee3.client.renderer.tileentity.TileEntityGlassBellRenderer.java

License:LGPL

private void renderGlassBellByOrientation(double x, double y, double z, ForgeDirection forgeDirection) {

    switch (forgeDirection) {
    case DOWN: {//w w  w .  ja  v a 2s.  co  m
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + 0.0F, (float) y + 2.0F, (float) z + 0.0F);
        GL11.glRotatef(90F, 1F, 0F, 0F);
        return;
    }
    case UP: {
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + 0.0F, (float) y + -1.0F, (float) z + 1.0F);
        GL11.glRotatef(-90F, 1F, 0F, 0F);
        return;
    }
    case NORTH: {
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + 1.0F, (float) y + 0.0F, (float) z + 2.0F);
        GL11.glRotatef(180F, 0F, 1F, 0F);
        return;
    }
    case SOUTH: {
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + 0.0F, (float) y + 0.0F, (float) z + -1.0F);
        return;
    }
    case EAST: {
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + -1.0F, (float) y + 1.0F, (float) z + 1.0F);
        GL11.glRotatef(-90F, 0F, 0F, 1F);
        GL11.glRotatef(-90F, 1F, 0F, 0F);
        return;
    }
    case WEST: {
        GL11.glScalef(1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float) x + 2.0F, (float) y + 0.0F, (float) z + 1.0F);
        GL11.glRotatef(90F, 0F, 0F, 1F);
        GL11.glRotatef(-90F, 1F, 0F, 0F);
        return;
    }
    case UNKNOWN: {
        return;
    }
    default: {
        return;
    }
    }
}

---

From source file:com.pahimar.ee3.core.handlers.DrawBlockHighlightHandler.java

License:LGPL

public void drawInWorldTransmutationOverlay(DrawBlockHighlightEvent event) {

    double x = event.target.blockX + 0.5F;
    double y = event.target.blockY + 0.5F;
    double z = event.target.blockZ + 0.5F;
    double iPX = event.player.prevPosX + (event.player.posX - event.player.prevPosX) * event.partialTicks;
    double iPY = event.player.prevPosY + (event.player.posY - event.player.prevPosY) * event.partialTicks;
    double iPZ = event.player.prevPosZ + (event.player.posZ - event.player.prevPosZ) * event.partialTicks;
    int texture = event.context.renderEngine.getTexture(Textures.EFFECT_WORLD_TRANSMUTATION);

    float xScale = 1;
    float yScale = 1;
    float zScale = 1;
    float xShift = 0.1F;
    float yShift = 0.1F;
    float zShift = 0.1F;
    int chargeLevel;
    int itemChargeLevel = 0;

    if (event.currentItem.getItem() instanceof IChargeable) {
        itemChargeLevel = ((IChargeable) event.currentItem.getItem()).getCharge(event.currentItem);
    }//from www .  j  a  v  a 2  s  .  co  m
    chargeLevel = 1 + itemChargeLevel * 2;

    ForgeDirection sideHit = ForgeDirection.getOrientation(event.target.sideHit);

    switch (sideHit) {
    case UP: {
        xScale = chargeLevel + 0.1F;
        zScale = chargeLevel + 0.1F;
        xShift = 0;
        zShift = 0;
        break;
    }
    case DOWN: {
        xScale = chargeLevel + 0.1F;
        zScale = chargeLevel + 0.1F;
        xShift = 0;
        yShift = -yShift;
        zShift = 0;
        break;
    }
    case NORTH: {
        xScale = chargeLevel + 0.1F;
        yScale = chargeLevel + 0.1F;
        xShift = 0;
        yShift = 0;
        zShift = -zShift;
        break;
    }
    case SOUTH: {
        xScale = chargeLevel + 0.1F;
        yScale = chargeLevel + 0.1F;
        xShift = 0;
        yShift = 0;
        break;
    }
    case EAST: {
        yScale = chargeLevel + 0.1F;
        zScale = chargeLevel + 0.1F;
        yShift = 0;
        zShift = 0;
        break;
    }
    case WEST: {
        yScale = chargeLevel + 0.1F;
        zScale = chargeLevel + 0.1F;
        xShift = -xShift;
        yShift = 0;
        zShift = 0;
        break;
    }
    default:
        break;
    }

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

    for (int i = 0; i < 6; 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);
        renderPulsingQuad(texture, 0.75F);
        GL11.glPopMatrix();
    }

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

---

• «
• 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
• »