Example usage for org.lwjgl.opengl GL11 glEnd

List of usage examples for org.lwjgl.opengl GL11 glEnd

  1. HOME
  2. Java
  3. org.lwjgl.opengl
  4. org.lwjgl.opengl.*
  5. GL11
  6. glEnd

Introduction

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

Prototype

public static native void glEnd();

Source Link

Document

Ends the definition of vertex attributes of a sequence of primitives to be transferred to the GL.

Usage

From source file:org.free.jake2.render.lwjgl.Draw.java

License:Open Source License

protected void Draw_Fill(int x, int y, int w, int h, int colorIndex) {

    if (colorIndex > 255) {
        Com.Error(Defines.ERR_FATAL, "Draw_Fill: bad color");
    }//w  w  w  .  jav  a2 s.  com

    GL11.glDisable(GL11.GL_TEXTURE_2D);

    int color = d_8to24table[colorIndex];

    GL11.glColor3ub((byte) ((color) & 0xff), // r
            (byte) ((color >> 8) & 0xff), // g
            (byte) ((color >> 16) & 0xff) // b
    );

    GL11.glBegin(GL11.GL_QUADS);

    GL11.glVertex2f(x, y);
    GL11.glVertex2f(x + w, y);
    GL11.glVertex2f(x + w, y + h);
    GL11.glVertex2f(x, y + h);

    GL11.glEnd();
    GL11.glColor3f(1, 1, 1);
    GL11.glEnable(GL11.GL_TEXTURE_2D);
}

From source file:org.free.jake2.render.lwjgl.Draw.java

License:Open Source License

protected void Draw_StretchRaw(int x, int y, int w, int h, int cols, int rows, byte[] data) {
    int i, j, trows;
    int sourceIndex;
    int frac, fracstep;
    float hscale;
    int row;/*from w w  w  .j  a v  a  2 s  .c om*/
    float t;

    GL_Bind(0);

    if (rows <= 256) {
        hscale = 1;
        trows = rows;
    } else {
        hscale = rows / 256.0f;
        trows = 256;
    }
    t = rows * hscale / 256;

    if (!qglColorTableEXT) {
        //int[] image32 = new int[256*256];
        image32.clear();
        int destIndex = 0;

        for (i = 0; i < trows; i++) {
            row = (int) (i * hscale);
            if (row > rows) {
                break;
            }
            sourceIndex = cols * row;
            destIndex = i * 256;
            fracstep = cols * 0x10000 / 256;
            frac = fracstep >> 1;
            for (j = 0; j < 256; j++) {
                image32.put(destIndex + j, r_rawpalette[data[sourceIndex + (frac >> 16)] & 0xff]);
                frac += fracstep;
            }
        }
        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, gl_tex_solid_format, 256, 256, 0, GL11.GL_RGBA,
                GL11.GL_UNSIGNED_BYTE, image32);
    } else {
        //byte[] image8 = new byte[256*256];
        image8.clear();
        int destIndex = 0;

        for (i = 0; i < trows; i++) {
            row = (int) (i * hscale);
            if (row > rows) {
                break;
            }
            sourceIndex = cols * row;
            destIndex = i * 256;
            fracstep = cols * 0x10000 / 256;
            frac = fracstep >> 1;
            for (j = 0; j < 256; j++) {
                image8.put(destIndex + j, data[sourceIndex + (frac >> 16)]);
                frac += fracstep;
            }
        }

        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, 256, 256, 0, GL11.GL_COLOR_INDEX,
                GL11.GL_UNSIGNED_BYTE, image8);
    }
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
    GL11.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);

    if ((gl_config.renderer == GL_RENDERER_MCD) || ((gl_config.renderer & GL_RENDERER_RENDITION) != 0)) {
        GL11.glDisable(GL11.GL_ALPHA_TEST);
    }

    GL11.glBegin(GL11.GL_QUADS);
    GL11.glTexCoord2f(0, 0);
    GL11.glVertex2f(x, y);
    GL11.glTexCoord2f(1, 0);
    GL11.glVertex2f(x + w, y);
    GL11.glTexCoord2f(1, t);
    GL11.glVertex2f(x + w, y + h);
    GL11.glTexCoord2f(0, t);
    GL11.glVertex2f(x, y + h);
    GL11.glEnd();

    if ((gl_config.renderer == GL_RENDERER_MCD) || ((gl_config.renderer & GL_RENDERER_RENDITION) != 0)) {
        GL11.glEnable(GL11.GL_ALPHA_TEST);
    }
}

From source file:org.free.jake2.render.lwjgl.Light.java

License:Open Source License

/**
 * R_RenderDlight/*www.j a va2  s . c o  m*/
 */
void R_RenderDlight(dlight_t light) {
    float rad = light.intensity * 0.35f;

    Math3D.VectorSubtract(light.origin, r_origin, v);

    GL11.glBegin(GL11.GL_TRIANGLE_FAN);
    GL11.glColor3f(light.color[0] * 0.2f, light.color[1] * 0.2f, light.color[2] * 0.2f);
    int i;
    for (i = 0; i < 3; i++) {
        v[i] = light.origin[i] - vpn[i] * rad;
    }

    GL11.glVertex3f(v[0], v[1], v[2]);
    GL11.glColor3f(0, 0, 0);

    int j;
    float a;
    for (i = 16; i >= 0; i--) {
        a = (float) (i / 16.0f * Math.PI * 2);
        for (j = 0; j < 3; j++) {
            v[j] = (float) (light.origin[j] + vright[j] * Math.cos(a) * rad + vup[j] * Math.sin(a) * rad);
        }
        GL11.glVertex3f(v[0], v[1], v[2]);
    }
    GL11.glEnd();
}

From source file:org.free.jake2.render.lwjgl.Main.java

License:Open Source License

/**
 * R_DrawSpriteModel//from ww  w.j a  va 2s . c  o  m
 */
void R_DrawSpriteModel(entity_t e) {
    float alpha = 1.0F;

    qfiles.dsprframe_t frame;
    qfiles.dsprite_t psprite;

    // don't even bother culling, because it's just a single
    // polygon without a surface cache

    psprite = (qfiles.dsprite_t) currentmodel.extradata;

    e.frame %= psprite.numframes;

    frame = psprite.frames[e.frame];

    if ((e.flags & Defines.RF_TRANSLUCENT) != 0) {
        alpha = e.alpha;
    }

    if (alpha != 1.0F) {
        GL11.glEnable(GL11.GL_BLEND);
    }

    GL11.glColor4f(1, 1, 1, alpha);

    GL_Bind(currentmodel.skins[e.frame].texnum);

    GL_TexEnv(GL11.GL_MODULATE);

    if (alpha == 1.0) {
        GL11.glEnable(GL11.GL_ALPHA_TEST);
    } else {
        GL11.glDisable(GL11.GL_ALPHA_TEST);
    }

    GL11.glBegin(GL11.GL_QUADS);

    GL11.glTexCoord2f(0, 1);
    Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
    Math3D.VectorMA(point, -frame.origin_x, vright, point);
    GL11.glVertex3f(point[0], point[1], point[2]);

    GL11.glTexCoord2f(0, 0);
    Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
    Math3D.VectorMA(point, -frame.origin_x, vright, point);
    GL11.glVertex3f(point[0], point[1], point[2]);

    GL11.glTexCoord2f(1, 0);
    Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point);
    Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
    GL11.glVertex3f(point[0], point[1], point[2]);

    GL11.glTexCoord2f(1, 1);
    Math3D.VectorMA(e.origin, -frame.origin_y, vup, point);
    Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point);
    GL11.glVertex3f(point[0], point[1], point[2]);

    GL11.glEnd();

    GL11.glDisable(GL11.GL_ALPHA_TEST);
    GL_TexEnv(GL11.GL_REPLACE);

    if (alpha != 1.0F) {
        GL11.glDisable(GL11.GL_BLEND);
    }

    GL11.glColor4f(1, 1, 1, 1);
}

From source file:org.free.jake2.render.lwjgl.Main.java

License:Open Source License

/**
 * R_PolyBlend//  w w w  .j  a  va  2  s .c o  m
 */
void R_PolyBlend() {
    if (gl_polyblend.value == 0.0f) {
        return;
    }

    if (v_blend[3] == 0.0f) {
        return;
    }

    GL11.glDisable(GL11.GL_ALPHA_TEST);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glDisable(GL11.GL_DEPTH_TEST);
    GL11.glDisable(GL11.GL_TEXTURE_2D);

    GL11.glLoadIdentity();

    // FIXME: get rid of these
    GL11.glRotatef(-90, 1, 0, 0); // put Z going up
    GL11.glRotatef(90, 0, 0, 1); // put Z going up

    GL11.glColor4f(v_blend[0], v_blend[1], v_blend[2], v_blend[3]);

    GL11.glBegin(GL11.GL_QUADS);

    GL11.glVertex3f(10, 100, 100);
    GL11.glVertex3f(10, -100, 100);
    GL11.glVertex3f(10, -100, -100);
    GL11.glVertex3f(10, 100, -100);
    GL11.glEnd();

    GL11.glDisable(GL11.GL_BLEND);
    GL11.glEnable(GL11.GL_TEXTURE_2D);
    GL11.glEnable(GL11.GL_ALPHA_TEST);

    GL11.glColor4f(1, 1, 1, 1);
}

From source file:org.free.jake2.render.lwjgl.Main.java

License:Open Source License

/**
 * R_DrawBeam//from  w  ww .  j  ava2  s .  co m
 */
void R_DrawBeam(entity_t e) {
    oldorigin[0] = e.oldorigin[0];
    oldorigin[1] = e.oldorigin[1];
    oldorigin[2] = e.oldorigin[2];

    origin[0] = e.origin[0];
    origin[1] = e.origin[1];
    origin[2] = e.origin[2];

    normalized_direction[0] = direction[0] = oldorigin[0] - origin[0];
    normalized_direction[1] = direction[1] = oldorigin[1] - origin[1];
    normalized_direction[2] = direction[2] = oldorigin[2] - origin[2];

    if (Math3D.VectorNormalize(normalized_direction) == 0.0f) {
        return;
    }

    Math3D.PerpendicularVector(perpvec, normalized_direction);
    Math3D.VectorScale(perpvec, e.frame / 2, perpvec);

    for (int i = 0; i < 6; i++) {
        Math3D.RotatePointAroundVector(start_points[i], normalized_direction, perpvec,
                (360.0f / NUM_BEAM_SEGS) * i);

        Math3D.VectorAdd(start_points[i], origin, start_points[i]);
        Math3D.VectorAdd(start_points[i], direction, end_points[i]);
    }

    GL11.glDisable(GL11.GL_TEXTURE_2D);
    GL11.glEnable(GL11.GL_BLEND);
    GL11.glDepthMask(false);

    float r = (d_8to24table[e.skinnum & 0xFF]) & 0xFF;
    float g = (d_8to24table[e.skinnum & 0xFF] >> 8) & 0xFF;
    float b = (d_8to24table[e.skinnum & 0xFF] >> 16) & 0xFF;

    r *= 1 / 255.0f;
    g *= 1 / 255.0f;
    b *= 1 / 255.0f;

    GL11.glColor4f(r, g, b, e.alpha);

    GL11.glBegin(GL11.GL_TRIANGLE_STRIP);

    float[] v;

    for (int i = 0; i < NUM_BEAM_SEGS; i++) {
        v = start_points[i];
        GL11.glVertex3f(v[0], v[1], v[2]);
        v = end_points[i];
        GL11.glVertex3f(v[0], v[1], v[2]);
        v = start_points[(i + 1) % NUM_BEAM_SEGS];
        GL11.glVertex3f(v[0], v[1], v[2]);
        v = end_points[(i + 1) % NUM_BEAM_SEGS];
        GL11.glVertex3f(v[0], v[1], v[2]);
    }
    GL11.glEnd();

    GL11.glEnable(GL11.GL_TEXTURE_2D);
    GL11.glDisable(GL11.GL_BLEND);
    GL11.glDepthMask(true);
}

From source file:org.free.jake2.render.lwjgl.Mesh.java

License:Open Source License

/**
 * GL_DrawAliasShadow/*from w  w  w  .j  a  va2  s .  c  om*/
 */
void GL_DrawAliasShadow(qfiles.dmdl_t paliashdr, int posenum) {
    float lheight = currententity.origin[2] - lightspot[2];
    qfiles.daliasframe_t frame = paliashdr.aliasFrames[currententity.frame];
    int[] order = paliashdr.glCmds;
    float height = -lheight + 1.0f;

    int orderIndex = 0;
    int index = 0;

    // TODO shadow drawing with vertex arrays
    int count;
    while (true) {
        // get the vertex count and primitive type
        count = order[orderIndex++];
        if (count == 0) {
            break; // done
        }
        if (count < 0) {
            count = -count;
            GL11.glBegin(GL11.GL_TRIANGLE_FAN);
        } else {
            GL11.glBegin(GL11.GL_TRIANGLE_STRIP);
        }

        do {
            index = order[orderIndex + 2] * 3;
            point[0] = vertexArrayBuf.get(index);
            point[1] = vertexArrayBuf.get(index + 1);
            point[2] = vertexArrayBuf.get(index + 2);

            point[0] -= shadevector[0] * (point[2] + lheight);
            point[1] -= shadevector[1] * (point[2] + lheight);
            point[2] = height;
            GL11.glVertex3f(point[0], point[1], point[2]);

            orderIndex += 3;

        } while (--count != 0);

        GL11.glEnd();
    }
}

From source file:org.free.jake2.render.lwjgl.Surf.java

License:Open Source License

/**
 * R_DrawTriangleOutlines//from  ww  w . j a  v a  2  s . co  m
 */
void R_DrawTriangleOutlines() {
    if (gl_showtris.value == 0) {
        return;
    }

    GL11.glDisable(GL11.GL_TEXTURE_2D);
    GL11.glDisable(GL11.GL_DEPTH_TEST);
    GL11.glColor4f(1, 1, 1, 1);

    msurface_t surf;
    glpoly_t p;
    int j;
    for (int i = 0; i < MAX_LIGHTMAPS; i++) {
        for (surf = gl_lms.lightmap_surfaces[i]; surf != null; surf = surf.lightmapchain) {
            for (p = surf.polys; p != null; p = p.chain) {
                for (j = 2; j < p.numverts; j++) {
                    GL11.glBegin(GL11.GL_LINE_STRIP);
                    GL11.glVertex3f(p.x(0), p.y(0), p.z(0));
                    GL11.glVertex3f(p.x(j - 1), p.y(j - 1), p.z(j - 1));
                    GL11.glVertex3f(p.x(j), p.y(j), p.z(j));
                    GL11.glVertex3f(p.x(0), p.y(0), p.z(0));
                    GL11.glEnd();
                }
            }
        }
    }

    GL11.glEnable(GL11.GL_DEPTH_TEST);
    GL11.glEnable(GL11.GL_TEXTURE_2D);
}

From source file:org.free.jake2.render.lwjgl.Warp.java

License:Open Source License

/**
 * EmitWaterPolys//w ww  . j a v  a 2  s  .c  om
 * Does a water warp on the pre-fragmented glpoly_t chain
 */
void EmitWaterPolys(msurface_t fa) {
    float rdt = r_newrefdef.time;

    float scroll;
    if ((fa.texinfo.flags & Defines.SURF_FLOWING) != 0) {
        scroll = -64 * ((r_newrefdef.time * 0.5f) - (int) (r_newrefdef.time * 0.5f));
    } else {
        scroll = 0;
    }

    int i;
    float s, t, os, ot;
    glpoly_t p, bp;
    for (bp = fa.polys; bp != null; bp = bp.next) {
        p = bp;

        GL11.glBegin(GL11.GL_TRIANGLE_FAN);
        for (i = 0; i < p.numverts; i++) {
            os = p.s1(i);
            ot = p.t1(i);

            s = os + Warp.SIN[(int) ((ot * 0.125f + r_newrefdef.time) * TURBSCALE) & 255];
            s += scroll;
            s *= (1.0f / 64);

            t = ot + Warp.SIN[(int) ((os * 0.125f + rdt) * TURBSCALE) & 255];
            t *= (1.0f / 64);

            GL11.glTexCoord2f(s, t);
            GL11.glVertex3f(p.x(i), p.y(i), p.z(i));
        }
        GL11.glEnd();
    }
}

From source file:org.free.jake2.render.lwjgl.Warp.java

License:Open Source License

/**
 * R_DrawSkyBox//from   w ww.j a v  a  2  s  .  c  o m
 */
void R_DrawSkyBox() {
    int i;

    if (skyrotate != 0) { // check for no sky at all
        for (i = 0; i < 6; i++) {
            if (skymins[0][i] < skymaxs[0][i] && skymins[1][i] < skymaxs[1][i]) {
                break;
            }
        }
        if (i == 6) {
            return; // nothing visible
        }
    }

    GL11.glPushMatrix();
    GL11.glTranslatef(r_origin[0], r_origin[1], r_origin[2]);
    GL11.glRotatef(r_newrefdef.time * skyrotate, skyaxis[0], skyaxis[1], skyaxis[2]);

    for (i = 0; i < 6; i++) {
        if (skyrotate != 0) { // hack, forces full sky to draw when rotating
            skymins[0][i] = -1;
            skymins[1][i] = -1;
            skymaxs[0][i] = 1;
            skymaxs[1][i] = 1;
        }

        if (skymins[0][i] >= skymaxs[0][i] || skymins[1][i] >= skymaxs[1][i]) {
            continue;
        }

        GL_Bind(sky_images[skytexorder[i]].texnum);

        GL11.glBegin(GL11.GL_QUADS);
        MakeSkyVec(skymins[0][i], skymins[1][i], i);
        MakeSkyVec(skymins[0][i], skymaxs[1][i], i);
        MakeSkyVec(skymaxs[0][i], skymaxs[1][i], i);
        MakeSkyVec(skymaxs[0][i], skymins[1][i], i);
        GL11.glEnd();
    }
    GL11.glPopMatrix();
}