diff options
Diffstat (limited to 'src/jake2/render/jogl/Surf.java')
| -rw-r--r-- | src/jake2/render/jogl/Surf.java | 1701 |
1 files changed, 1701 insertions, 0 deletions
diff --git a/src/jake2/render/jogl/Surf.java b/src/jake2/render/jogl/Surf.java new file mode 100644 index 0000000..7baf69f --- /dev/null +++ b/src/jake2/render/jogl/Surf.java @@ -0,0 +1,1701 @@ +/* + * Surf.java + * Copyright (C) 2003 + * + * $Id: Surf.java,v 1.1 2004-07-07 19:59:43 hzi Exp $ + */ +/* +Copyright (C) 1997-2001 Id Software, Inc. + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ +package jake2.render.jogl; + +import java.awt.geom.AffineTransform; +import java.awt.image.AffineTransformOp; +import java.awt.image.BufferedImage; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; +import java.util.Arrays; +import java.util.Collection; +import java.util.Iterator; + +import net.java.games.jogl.GL; +import jake2.Defines; +import jake2.client.dlight_t; +import jake2.client.entity_t; +import jake2.client.lightstyle_t; +import jake2.game.cplane_t; +import jake2.imageio.ImageFrame; +import jake2.render.glpoly_t; +import jake2.render.image_t; +import jake2.render.medge_t; +import jake2.render.mleaf_t; +import jake2.render.mnode_t; +import jake2.render.model_t; +import jake2.render.msurface_t; +import jake2.render.mtexinfo_t; +import jake2.util.Lib; +import jake2.util.Math3D; + +/** + * Surf + * + * @author cwei + */ +public abstract class Surf extends Draw { + + // GL_RSURF.C: surface-related refresh code + float[] modelorg = {0, 0, 0}; // relative to viewpoint + + msurface_t r_alpha_surfaces; + + static final int DYNAMIC_LIGHT_WIDTH = 128; + static final int DYNAMIC_LIGHT_HEIGHT = 128; + + static final int LIGHTMAP_BYTES = 4; + + static final int BLOCK_WIDTH = 128; + static final int BLOCK_HEIGHT = 128; + + static final int MAX_LIGHTMAPS = 128; + + int c_visible_lightmaps; + int c_visible_textures; + + static final int GL_LIGHTMAP_FORMAT = GL.GL_RGBA; + + static class gllightmapstate_t + { + int internal_format; + int current_lightmap_texture; + + msurface_t[] lightmap_surfaces = new msurface_t[MAX_LIGHTMAPS]; + + int[] allocated = new int[BLOCK_WIDTH]; + + // the lightmap texture data needs to be kept in + // main memory so texsubimage can update properly + byte[] lightmap_buffer = new byte[4 * BLOCK_WIDTH * BLOCK_HEIGHT]; + + public void clearLightmapSurfaces() { + for (int i = 0; i < MAX_LIGHTMAPS; i++) + lightmap_surfaces[i] = new msurface_t(); + } + + } + + gllightmapstate_t gl_lms = new gllightmapstate_t(); + +// +// static void LM_InitBlock( void ); +// static void LM_UploadBlock( qboolean dynamic ); +// static qboolean LM_AllocBlock (int w, int h, int *x, int *y); +// +// extern void R_SetCacheState( msurface_t *surf ); +// extern void R_BuildLightMap (msurface_t *surf, byte *dest, int stride); +// + + // Model.java + abstract byte[] Mod_ClusterPVS(int cluster, model_t model); + // Warp.java + abstract void R_DrawSkyBox(); + abstract void R_AddSkySurface(msurface_t surface); + abstract void R_ClearSkyBox(); + abstract void EmitWaterPolys(msurface_t fa); + // Light.java + abstract void R_MarkLights (dlight_t light, int bit, mnode_t node); + abstract void R_SetCacheState( msurface_t surf ); + abstract void R_BuildLightMap(msurface_t surf, ByteBuffer dest, int stride); + + /* + ============================================================= + + BRUSH MODELS + + ============================================================= + */ + + /* + =============== + R_TextureAnimation + + Returns the proper texture for a given time and base texture + =============== + */ + image_t R_TextureAnimation(mtexinfo_t tex) + { + int c; + + if (tex.next == null) + return tex.image; + + c = currententity.frame % tex.numframes; + while (c != 0) + { + tex = tex.next; + c--; + } + + return tex.image; + } + + /* + ================ + DrawGLPoly + ================ + */ + void DrawGLPoly(glpoly_t p) + { + int i; + float[] v; + + gl.glBegin(GL.GL_POLYGON); + for (i=0 ; i<p.numverts ; i++) + { + v = p.verts[i]; + gl.glTexCoord2f(v[3], v[4]); + gl.glVertex3fv(v); + } + gl.glEnd(); + } + + // ============ + // PGM + /* + ================ + DrawGLFlowingPoly -- version of DrawGLPoly that handles scrolling texture + ================ + */ + void DrawGLFlowingPoly(msurface_t fa) + { + int i; + float[] v; + glpoly_t p; + float scroll; + + p = fa.polys; + + scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) ); + if(scroll == 0.0f) + scroll = -64.0f; + + gl.glBegin (GL.GL_POLYGON); + for (i=0 ; i<p.numverts ; i++) + { + v = p.verts[i]; + gl.glTexCoord2f ((v[3] + scroll), v[4]); + gl.glVertex3fv( v ); + } + gl.glEnd (); + } + // PGM + // ============ + + /* + ** R_DrawTriangleOutlines + */ + void R_DrawTriangleOutlines() + { + int i, j; + glpoly_t p; + + if (gl_showtris.value == 0) + return; + + gl.glDisable (GL.GL_TEXTURE_2D); + gl.glDisable (GL.GL_DEPTH_TEST); + gl.glColor4f (1,1,1,1); + + for (i=0 ; i<MAX_LIGHTMAPS ; i++) + { + msurface_t surf; + + for ( surf = gl_lms.lightmap_surfaces[i]; surf != null; surf = surf.lightmapchain ) + { + p = surf.polys; + for ( ; p != null ; p=p.chain) + { + for (j=2 ; j<p.numverts ; j++ ) + { + gl.glBegin (GL.GL_LINE_STRIP); + gl.glVertex3fv (p.verts[0]); + gl.glVertex3fv (p.verts[j-1]); + gl.glVertex3fv (p.verts[j]); + gl.glVertex3fv (p.verts[0]); + gl.glEnd (); + } + } + } + } + + gl.glEnable (GL.GL_DEPTH_TEST); + gl.glEnable (GL.GL_TEXTURE_2D); + } + + /* + ** DrawGLPolyChain + */ + void DrawGLPolyChain( glpoly_t p, float soffset, float toffset ) + { + if ( soffset == 0 && toffset == 0 ) + { + for ( ; p != null; p = p.chain ) + { + float[] v; + int j; + + gl.glBegin(GL.GL_POLYGON); + for (j=0 ; j<p.numverts ; j++) + { + v = p.verts[j]; + gl.glTexCoord2f (v[5], v[6] ); + gl.glVertex3fv( v ); + } + gl.glEnd(); + } + } + else + { + for ( ; p != null; p = p.chain ) + { + float[] v; + int j; + + gl.glBegin(GL.GL_POLYGON); + for (j=0 ; j<p.numverts ; j++) + { + v = p.verts[j]; + gl.glTexCoord2f (v[5] - soffset, v[6] - toffset ); + gl.glVertex3fv( v ); + } + gl.glEnd(); + } + } + } + + /* + ** R_BlendLightMaps + ** + ** This routine takes all the given light mapped surfaces in the world and + ** blends them into the framebuffer. + */ + void R_BlendLightmaps() + { + int i; + msurface_t surf; + msurface_t newdrawsurf = null; + + // don't bother if we're set to fullbright + if (r_fullbright.value != 0) + return; + if (r_worldmodel.lightdata == null) + return; + + // don't bother writing Z + gl.glDepthMask( false ); + + /* + ** set the appropriate blending mode unless we're only looking at the + ** lightmaps. + */ + if (gl_lightmap.value == 0) + { + gl.glEnable(GL.GL_BLEND); + + if ( gl_saturatelighting.value != 0) + { + gl.glBlendFunc( GL.GL_ONE, GL.GL_ONE ); + } + else + { + char format = gl_monolightmap.string.toUpperCase().charAt(0); + if ( format != '0' ) + { + switch ( format ) + { + case 'I': + gl.glBlendFunc(GL.GL_ZERO, GL.GL_SRC_COLOR ); + break; + case 'L': + gl.glBlendFunc(GL.GL_ZERO, GL.GL_SRC_COLOR ); + break; + case 'A': + default: + gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA ); + break; + } + } + else + { + gl.glBlendFunc(GL.GL_ZERO, GL.GL_SRC_COLOR ); + } + } + } + + if ( currentmodel == r_worldmodel ) + c_visible_lightmaps = 0; + + /* + ** render static lightmaps first + */ + for ( i = 1; i < MAX_LIGHTMAPS; i++ ) + { + if ( gl_lms.lightmap_surfaces[i] != null ) + { + if (currentmodel == r_worldmodel) + c_visible_lightmaps++; + + GL_Bind( gl_state.lightmap_textures + i); + + for ( surf = gl_lms.lightmap_surfaces[i]; surf != null; surf = surf.lightmapchain ) + { + if ( surf.polys != null ) + DrawGLPolyChain( surf.polys, 0, 0 ); + } + } + } + + + // TODO impl: render dynamic lightmaps + + /* + ** render dynamic lightmaps + */ + if ( gl_dynamic.value != 0 ) + { + LM_InitBlock(); + + GL_Bind( gl_state.lightmap_textures+0 ); + + if (currentmodel == r_worldmodel) + c_visible_lightmaps++; + + newdrawsurf = gl_lms.lightmap_surfaces[0]; + + for ( surf = gl_lms.lightmap_surfaces[0]; surf != null; surf = surf.lightmapchain ) + { +// int smax, tmax; +// byte *base; +// +// smax = (surf->extents[0]>>4)+1; +// tmax = (surf->extents[1]>>4)+1; +// +// if ( LM_AllocBlock( smax, tmax, &surf->dlight_s, &surf->dlight_t ) ) +// { +// base = gl_lms.lightmap_buffer; +// base += ( surf->dlight_t * BLOCK_WIDTH + surf->dlight_s ) * LIGHTMAP_BYTES; +// +// R_BuildLightMap (surf, base, BLOCK_WIDTH*LIGHTMAP_BYTES); +// } +// else +// { +// msurface_t *drawsurf; +// +// // upload what we have so far +// LM_UploadBlock( true ); +// +// // draw all surfaces that use this lightmap +// for ( drawsurf = newdrawsurf; drawsurf != surf; drawsurf = drawsurf->lightmapchain ) +// { +// if ( drawsurf->polys ) +// DrawGLPolyChain( drawsurf->polys, +// ( drawsurf->light_s - drawsurf->dlight_s ) * ( 1.0 / 128.0 ), +// ( drawsurf->light_t - drawsurf->dlight_t ) * ( 1.0 / 128.0 ) ); +// } +// +// newdrawsurf = drawsurf; +// +// // clear the block +// LM_InitBlock(); +// +// // try uploading the block now +// if ( !LM_AllocBlock( smax, tmax, &surf->dlight_s, &surf->dlight_t ) ) +// { +// ri.Sys_Error( ERR_FATAL, "Consecutive calls to LM_AllocBlock(%d,%d) failed (dynamic)\n", smax, tmax ); +// } +// +// base = gl_lms.lightmap_buffer; +// base += ( surf->dlight_t * BLOCK_WIDTH + surf->dlight_s ) * LIGHTMAP_BYTES; +// +// R_BuildLightMap (surf, base, BLOCK_WIDTH*LIGHTMAP_BYTES); +// } + } + + /* + ** draw remainder of dynamic lightmaps that haven't been uploaded yet + */ +// if ( newdrawsurf != null ) +// LM_UploadBlock( true ); +// +// for ( surf = newdrawsurf; surf != null; surf = surf.lightmapchain ) +// { +// if ( surf.polys != null ) +// DrawGLPolyChain( surf.polys, ( surf.light_s - surf.dlight_s ) * ( 1.0f / 128.0f ), ( surf.light_t - surf.dlight_t ) * ( 1.0f / 128.0f ) ); +// } + } + + /* + ** restore state + */ + gl.glDisable(GL.GL_BLEND); + gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); + gl.glDepthMask( true ); + } + + /* + ================ + R_RenderBrushPoly + ================ + */ + void R_RenderBrushPoly(msurface_t fa) + { + int maps; + image_t image; + boolean is_dynamic = false; + + c_brush_polys++; + + image = R_TextureAnimation(fa.texinfo); + + if ((fa.flags & Defines.SURF_DRAWTURB) != 0) + { + GL_Bind( image.texnum ); + + // warp texture, no lightmaps + GL_TexEnv( GL.GL_MODULATE ); + gl.glColor4f( gl_state.inverse_intensity, + gl_state.inverse_intensity, + gl_state.inverse_intensity, + 1.0F ); + EmitWaterPolys (fa); + GL_TexEnv( GL.GL_REPLACE ); + + return; + } + else + { + GL_Bind( image.texnum ); + GL_TexEnv( GL.GL_REPLACE ); + } + + // ====== + // PGM + if((fa.texinfo.flags & Defines.SURF_FLOWING) != 0) + DrawGLFlowingPoly(fa); + else + DrawGLPoly (fa.polys); + // PGM + // ====== + +// /* +// ** check for lightmap modification +// */ +// for ( maps = 0; maps < MAXLIGHTMAPS && fa->styles[maps] != 255; maps++ ) +// { +// if ( r_newrefdef.lightstyles[fa->styles[maps]].white != fa->cached_light[maps] ) +// goto dynamic; +// } +// +// // dynamic this frame or dynamic previously +// if ( ( fa->dlightframe == r_framecount ) ) +// { +// dynamic: +// if ( gl_dynamic->value ) +// { +// if (!( fa->texinfo->flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP ) ) ) +// { +// is_dynamic = true; +// } +// } +// } +// + if ( is_dynamic ) + { +// if ( ( fa->styles[maps] >= 32 || fa->styles[maps] == 0 ) && ( fa->dlightframe != r_framecount ) ) +// { +// unsigned temp[34*34]; +// int smax, tmax; +// +// smax = (fa->extents[0]>>4)+1; +// tmax = (fa->extents[1]>>4)+1; +// +// R_BuildLightMap( fa, (void *)temp, smax*4 ); +// R_SetCacheState( fa ); +// +// GL_Bind( gl_state.lightmap_textures + fa->lightmaptexturenum ); +// +// qglTexSubImage2D( GL_TEXTURE_2D, 0, +// fa->light_s, fa->light_t, +// smax, tmax, +// GL_LIGHTMAP_FORMAT, +// GL_UNSIGNED_BYTE, temp ); +// +// fa->lightmapchain = gl_lms.lightmap_surfaces[fa->lightmaptexturenum]; +// gl_lms.lightmap_surfaces[fa->lightmaptexturenum] = fa; +// } +// else +// { +// fa->lightmapchain = gl_lms.lightmap_surfaces[0]; +// gl_lms.lightmap_surfaces[0] = fa; +// } + } + else + { + fa.lightmapchain = gl_lms.lightmap_surfaces[fa.lightmaptexturenum]; + gl_lms.lightmap_surfaces[fa.lightmaptexturenum] = fa; + } + } + + + /* + ================ + R_DrawAlphaSurfaces + + Draw water surfaces and windows. + The BSP tree is waled front to back, so unwinding the chain + of alpha_surfaces will draw back to front, giving proper ordering. + ================ + */ + void R_DrawAlphaSurfaces() + { + msurface_t s; + float intens; + + // + // go back to the world matrix + // + gl.glLoadMatrixf(r_world_matrix); + + gl.glEnable (GL.GL_BLEND); + GL_TexEnv(GL.GL_MODULATE ); + + // the textures are prescaled up for a better lighting range, + // so scale it back down + intens = gl_state.inverse_intensity; + + for (s=r_alpha_surfaces ; s != null ; s=s.texturechain) + { + GL_Bind(s.texinfo.image.texnum); + c_brush_polys++; + if ((s.texinfo.flags & Defines.SURF_TRANS33) != 0) + gl.glColor4f (intens, intens, intens, 0.33f); + else if ((s.texinfo.flags & Defines.SURF_TRANS66) != 0) + gl.glColor4f (intens, intens, intens, 0.66f); + else + gl.glColor4f (intens,intens,intens,1); + if ((s.flags & Defines.SURF_DRAWTURB) != 0) + EmitWaterPolys(s); + else if((s.texinfo.flags & Defines.SURF_FLOWING) != 0) // PGM 9/16/98 + DrawGLFlowingPoly (s); // PGM + else + DrawGLPoly (s.polys); + } + + GL_TexEnv( GL.GL_REPLACE ); + gl.glColor4f (1,1,1,1); + gl.glDisable (GL.GL_BLEND); + + r_alpha_surfaces = null; + } + + /* + ================ + DrawTextureChains + ================ + */ + void DrawTextureChains() + { + int i; + msurface_t s; + image_t image; + + c_visible_textures = 0; + + + if ( !qglSelectTextureSGIS && !qglActiveTextureARB ) + { + for (i = 0; i < numgltextures ; i++) + { + image = gltextures[i]; + if (image.registration_sequence == 0) + continue; + s = image.texturechain; + if (s == null) + continue; + c_visible_textures++; + + for ( ; s != null ; s=s.texturechain) + R_RenderBrushPoly(s); + + image.texturechain = null; + } + } + else + { + for (i = 0; i < numgltextures ; i++) + { + image = gltextures[i]; + + if (image.registration_sequence == 0) + continue; + if (image.texturechain == null) + continue; + c_visible_textures++; + + for ( s = image.texturechain; s != null ; s=s.texturechain) + { + if ( ( s.flags & Defines.SURF_DRAWTURB) == 0 ) + R_RenderBrushPoly(s); + } + } + + GL_EnableMultitexture( false ); + for (i = 0; i < numgltextures ; i++) + { + image = gltextures[i]; + + if (image.registration_sequence == 0) + continue; + s = image.texturechain; + if (s == null) + continue; + + for ( ; s != null ; s=s.texturechain) + { + if ( (s.flags & Defines.SURF_DRAWTURB) != 0 ) + R_RenderBrushPoly(s); + } + + image.texturechain = null; + } + } + + GL_TexEnv( GL.GL_REPLACE ); + } + + + void GL_RenderLightmappedPoly( msurface_t surf ) + { + int i, nv = surf.polys.numverts; + int map = 0; + float[] v; + image_t image = R_TextureAnimation( surf.texinfo ); + boolean is_dynamic = false; + int lmtex = surf.lightmaptexturenum; + glpoly_t p; + +// for ( map = 0; map < Defines.MAXLIGHTMAPS && surf.styles[map] != (byte)255; map++ ) +// { +// if ( r_newrefdef.lightstyles[surf.styles[map] & 0xFF].white != surf.cached_light[map] ) +// goto dynamic; +// } +// +// // dynamic this frame or dynamic previously +// if ( ( surf.dlightframe == r_framecount ) ) +// { +// dynamic: +// if ( gl_dynamic.value ) +// { +// if ( !(surf.texinfo.flags & (SURF_SKY|SURF_TRANS33|SURF_TRANS66|SURF_WARP ) ) ) +// { +// is_dynamic = true; +// } +// } +// } +// + if ( is_dynamic ) + { +// unsigned temp[128*128]; +// int smax, tmax; +// + if ( ( (surf.styles[map] & 0xFF) >= 32 || surf.styles[map] == 0 ) && ( surf.dlightframe != r_framecount ) ) + { +// smax = (surf.extents[0]>>4)+1; +// tmax = (surf.extents[1]>>4)+1; +// +// R_BuildLightMap( surf, (void *)temp, smax*4 ); +// R_SetCacheState( surf ); +// +// GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + surf.lightmaptexturenum ); +// +// lmtex = surf.lightmaptexturenum; +// +// gl.glTexSubImage2D( GL_TEXTURE_2D, 0, +// surf.light_s, surf.light_t, +// smax, tmax, +// GL_LIGHTMAP_FORMAT, +// GL_UNSIGNED_BYTE, temp ); +// + } + else + { +// smax = (surf.extents[0]>>4)+1; +// tmax = (surf.extents[1]>>4)+1; +// +// R_BuildLightMap( surf, (void *)temp, smax*4 ); +// +// GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + 0 ); +// +// lmtex = 0; +// +// gl.glTexSubImage2D( GL_TEXTURE_2D, 0, +// surf.light_s, surf.light_t, +// smax, tmax, +// GL_LIGHTMAP_FORMAT, +// GL_UNSIGNED_BYTE, temp ); +// + } + + c_brush_polys++; + + GL_MBind( GL_TEXTURE0, image.texnum ); + GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + lmtex ); + + // ========== + // PGM + if ((surf.texinfo.flags & Defines.SURF_FLOWING) != 0) + { + float scroll; + + scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) ); + if(scroll == 0.0f) + scroll = -64.0f; + + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glBegin (GL.GL_POLYGON); + for (i=0 ; i< nv; i++) + { + v = p.verts[i]; + + gl.glMultiTexCoord2fARB(GL_TEXTURE0, (v[3] + scroll), v[4]); + gl.glMultiTexCoord2fARB(GL_TEXTURE1, v[5], v[6]); + //gglMTexCoord2fSGIS( GL_TEXTURE0, v[3], v[4]); + //gglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3fv(v); + } + gl.glEnd (); + } + } + else + { + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glBegin (GL.GL_POLYGON); + for (i=0 ; i< nv; i++) + { + v = p.verts[i]; + + gl.glMultiTexCoord2fARB(GL_TEXTURE0, v[3], v[4]); + gl.glMultiTexCoord2fARB(GL_TEXTURE1, v[5], v[6]); + //gglMTexCoord2fSGIS( GL_TEXTURE0, v[3], v[4]); + //gglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3fv(v); + } + gl.glEnd (); + } + } + // PGM + // ========== + } + else + { + c_brush_polys++; + + GL_MBind( GL_TEXTURE0, image.texnum ); + GL_MBind( GL_TEXTURE1, gl_state.lightmap_textures + lmtex); + + // ========== + // PGM + if ((surf.texinfo.flags & Defines.SURF_FLOWING) != 0) + { + float scroll; + + scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) ); + if(scroll == 0.0) + scroll = -64.0f; + + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glBegin(GL.GL_POLYGON); + for (i=0 ; i< nv; i++) + { + v = p.verts[i]; + + gl.glMultiTexCoord2fARB(GL_TEXTURE0, (v[3]+scroll), v[4]); + gl.glMultiTexCoord2fARB(GL_TEXTURE1, v[5], v[6]); + // qglMTexCoord2fSGIS( GL_TEXTURE0, (v[3]+scroll), v[4]); + // qglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3fv(v); + } + gl.glEnd(); + } + } + else + { + // PGM + // ========== + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glBegin (GL.GL_POLYGON); + for (i=0 ; i< nv; i++) + { + v = p.verts[i]; + + gl.glMultiTexCoord2fARB(GL_TEXTURE0, v[3], v[4]); + gl.glMultiTexCoord2fARB(GL_TEXTURE1, v[5], v[6]); + //gglMTexCoord2fSGIS( GL_TEXTURE0, v[3], v[4]); + //gglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3fv(v); + } + gl.glEnd (); + } + // ========== + // PGM + } + // PGM + // ========== + } + } + + /* + ================= + R_DrawInlineBModel + ================= + */ + void R_DrawInlineBModel() + { + int i, k; + cplane_t pplane; + float dot; + msurface_t psurf; + dlight_t lt; + + // calculate dynamic lighting for bmodel + if ( gl_flashblend.value == 0 ) + { + for (k=0 ; k<r_newrefdef.num_dlights ; k++) + { + lt = r_newrefdef.dlights[k]; + R_MarkLights(lt, 1<<k, currentmodel.nodes[currentmodel.firstnode]); + } + } + + // psurf = ¤tmodel->surfaces[currentmodel->firstmodelsurface]; + int psurfp = currentmodel.firstmodelsurface; + msurface_t[] surfaces; + surfaces = currentmodel.surfaces; + //psurf = surfaces[psurfp]; + + if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 ) + { + gl.glEnable (GL.GL_BLEND); + gl.glColor4f (1,1,1,0.25f); + GL_TexEnv( GL.GL_MODULATE ); + } + + // + // draw texture + // + for (i=0 ; i<currentmodel.nummodelsurfaces ; i++) + { + psurf = surfaces[psurfp++]; + // find which side of the node we are on + pplane = psurf.plane; + + dot = Math3D.DotProduct(modelorg, pplane.normal) - pplane.dist; + + // draw the polygon + if (((psurf.flags & Defines.SURF_PLANEBACK) != 0 && (dot < -BACKFACE_EPSILON)) || + ((psurf.flags & Defines.SURF_PLANEBACK) == 0 && (dot > BACKFACE_EPSILON))) + { + if ((psurf.texinfo.flags & (Defines.SURF_TRANS33 | Defines.SURF_TRANS66)) != 0 ) + { // add to the translucent chain + psurf.texturechain = r_alpha_surfaces; + r_alpha_surfaces = psurf; + } + else if ( qglMTexCoord2fSGIS && ( psurf.flags & Defines.SURF_DRAWTURB ) == 0 ) + { + GL_RenderLightmappedPoly( psurf ); + } + else + { + GL_EnableMultitexture( false ); + R_RenderBrushPoly( psurf ); + GL_EnableMultitexture( true ); + } + } + } + + if ( (currententity.flags & Defines.RF_TRANSLUCENT) == 0 ) + { + if ( !qglMTexCoord2fSGIS ) + R_BlendLightmaps(); + } + else + { + gl.glDisable (GL.GL_BLEND); + gl.glColor4f (1,1,1,1); + GL_TexEnv( GL.GL_REPLACE ); + } + } + + /* + ================= + R_DrawBrushModel + ================= + */ + void R_DrawBrushModel(entity_t e) + { + float[] mins = {0, 0, 0}; + float[] maxs = {0, 0, 0}; + int i; + boolean rotated; + + if (currentmodel.nummodelsurfaces == 0) + return; + + currententity = e; + gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1; + + if (e.angles[0] != 0 || e.angles[1] != 0 || e.angles[2] != 0) + { + rotated = true; + for (i=0 ; i<3 ; i++) + { + mins[i] = e.origin[i] - currentmodel.radius; + maxs[i] = e.origin[i] + currentmodel.radius; + //System.out.println("rotate: " + Lib.vtos(mins) + " " + Lib.vtos(maxs)); + } + } + else + { + rotated = false; + Math3D.VectorAdd(e.origin, currentmodel.mins, mins); + Math3D.VectorAdd(e.origin, currentmodel.maxs, maxs); + //System.out.println(" " + Lib.vtos(mins) + " " + Lib.vtos(maxs)); + } + + if (R_CullBox(mins, maxs)) { + //System.out.println("origin " + Lib.vtos(e.origin) + " +++ " + Lib.vtos(currentmodel.mins)); + return; + } + + gl.glColor3f (1,1,1); + + // memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces)); + gl_lms.clearLightmapSurfaces(); + + Math3D.VectorSubtract (r_newrefdef.vieworg, e.origin, modelorg); + if (rotated) + { + float[] temp = {0, 0, 0}; + float[] forward = {0, 0, 0}; + float[] right = {0, 0, 0}; + float[] up = {0, 0, 0}; + + Math3D.VectorCopy (modelorg, temp); + Math3D.AngleVectors (e.angles, forward, right, up); + modelorg[0] = Math3D.DotProduct (temp, forward); + modelorg[1] = -Math3D.DotProduct (temp, right); + modelorg[2] = Math3D.DotProduct (temp, up); + } + + gl.glPushMatrix(); + + e.angles[0] = -e.angles[0]; // stupid quake bug + e.angles[2] = -e.angles[2]; // stupid quake bug + R_RotateForEntity(e); + e.angles[0] = -e.angles[0]; // stupid quake bug + e.angles[2] = -e.angles[2]; // stupid quake bug + + GL_EnableMultitexture( true ); + GL_SelectTexture(GL_TEXTURE0); + GL_TexEnv( GL.GL_REPLACE ); + GL_SelectTexture(GL_TEXTURE1); + GL_TexEnv( GL.GL_MODULATE ); + + R_DrawInlineBModel(); + GL_EnableMultitexture( false ); + + gl.glPopMatrix(); + } + + /* + ============================================================= + + WORLD MODEL + + ============================================================= + */ + + /* + ================ + R_RecursiveWorldNode + ================ + */ + void R_RecursiveWorldNode (mnode_t node) + { + int c, side, sidebit; + cplane_t plane; + msurface_t surf; + msurface_t mark; + mleaf_t pleaf; + float dot = 0; + image_t image; + + if (node.contents == Defines.CONTENTS_SOLID) + return; // solid + + if (node.visframe != r_visframecount) + return; + + if (R_CullBox(node.mins, node.maxs)) + return; + + // if a leaf node, draw stuff + if (node.contents != -1) + { + pleaf = (mleaf_t)node; + + // check for door connected areas + if (r_newrefdef.areabits != null) + { + if ( ((r_newrefdef.areabits[pleaf.area >> 3] & 0xFF) & (1 << (pleaf.area & 7)) ) == 0 ) + return; // not visible + } + + int markp = 0; + + mark = pleaf.getMarkSurface(markp); // first marked surface + c = pleaf.nummarksurfaces; + + if (c != 0) + { + do + { + mark.visframe = r_framecount; + mark = pleaf.getMarkSurface(++markp); // next surface + } while (--c != 0); + } + + return; + } + + // node is just a decision point, so go down the apropriate sides + + // find which side of the node we are on + plane = node.plane; + + switch (plane.type) + { + case Defines.PLANE_X: + dot = modelorg[0] - plane.dist; + break; + case Defines.PLANE_Y: + dot = modelorg[1] - plane.dist; + break; + case Defines.PLANE_Z: + dot = modelorg[2] - plane.dist; + break; + default: + dot = Math3D.DotProduct(modelorg, plane.normal) - plane.dist; + break; + } + + if (dot >= 0.0f) + { + side = 0; + sidebit = 0; + } + else + { + side = 1; + sidebit = Defines.SURF_PLANEBACK; + } + + // recurse down the children, front side first + R_RecursiveWorldNode(node.children[side]); + + // draw stuff + //for ( c = node.numsurfaces, surf = r_worldmodel.surfaces[node.firstsurface]; c != 0 ; c--, surf++) + for ( c = 0; c < node.numsurfaces; c++) + { + surf = r_worldmodel.surfaces[node.firstsurface + c]; + if (surf.visframe != r_framecount) + continue; + + if ( (surf.flags & Defines.SURF_PLANEBACK) != sidebit ) + continue; // wrong side + + if ((surf.texinfo.flags & Defines.SURF_SKY) != 0) + { // just adds to visible sky bounds + R_AddSkySurface(surf); + } + else if ((surf.texinfo.flags & (Defines.SURF_TRANS33 | Defines.SURF_TRANS66)) != 0) + { // add to the translucent chain + surf.texturechain = r_alpha_surfaces; + r_alpha_surfaces = surf; + } + else + { + if ( qglMTexCoord2fSGIS && ( surf.flags & Defines.SURF_DRAWTURB) == 0 ) + { + GL_RenderLightmappedPoly( surf ); + } + else + { + // the polygon is visible, so add it to the texture + // sorted chain + // FIXME: this is a hack for animation + image = R_TextureAnimation(surf.texinfo); + surf.texturechain = image.texturechain; + image.texturechain = surf; + } + } + } + + // recurse down the back side + R_RecursiveWorldNode(node.children[1 - side]); + } + + + /* + ============= + R_DrawWorld + ============= + */ + void R_DrawWorld() + { + entity_t ent = new entity_t(); + + if (r_drawworld.value == 0) + return; + + if ( (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0 ) + return; + + currentmodel = r_worldmodel; + + Math3D.VectorCopy(r_newrefdef.vieworg, modelorg); + + // auto cycle the world frame for texture animation + // memset (&ent, 0, sizeof(ent)); + ent.frame = (int)(r_newrefdef.time*2); + currententity = ent; + + gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1; + + gl.glColor3f (1,1,1); + // memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces)); + gl_lms.clearLightmapSurfaces(); + + R_ClearSkyBox(); + + if ( qglMTexCoord2fSGIS ) + { + GL_EnableMultitexture( true ); + + GL_SelectTexture( GL_TEXTURE0); + GL_TexEnv( GL.GL_REPLACE ); + GL_SelectTexture( GL_TEXTURE1); + + if ( gl_lightmap.value != 0) + GL_TexEnv( GL.GL_REPLACE ); + else + GL_TexEnv( GL.GL_MODULATE ); + + R_RecursiveWorldNode(r_worldmodel.nodes[0]); // root node + + GL_EnableMultitexture( false ); + } + else + { + R_RecursiveWorldNode(r_worldmodel.nodes[0]); // root node + } + + /* + ** theoretically nothing should happen in the next two functions + ** if multitexture is enabled + */ + DrawTextureChains(); + R_BlendLightmaps(); + + R_DrawSkyBox(); + + R_DrawTriangleOutlines(); + } + + byte[] fatvis = new byte[Defines.MAX_MAP_LEAFS / 8]; + + /* + =============== + R_MarkLeaves + + Mark the leaves and nodes that are in the PVS for the current + cluster + =============== + */ + void R_MarkLeaves() + { + byte[] vis; + //byte[] fatvis = new byte[Defines.MAX_MAP_LEAFS / 8]; + + Arrays.fill(fatvis, (byte)0); + + mnode_t node; + int i, c; + mleaf_t leaf; + int cluster; + + if (r_oldviewcluster == r_viewcluster && r_oldviewcluster2 == r_viewcluster2 && r_novis.value == 0 && r_viewcluster != -1) + return; + + // development aid to let you run around and see exactly where + // the pvs ends + if (gl_lockpvs.value != 0) + return; + + r_visframecount++; + r_oldviewcluster = r_viewcluster; + r_oldviewcluster2 = r_viewcluster2; + + if (r_novis.value != 0 || r_viewcluster == -1 || r_worldmodel.vis == null) + { + // mark everything + for (i=0 ; i<r_worldmodel.numleafs ; i++) + r_worldmodel.leafs[i].visframe = r_visframecount; + for (i=0 ; i<r_worldmodel.numnodes ; i++) + r_worldmodel.nodes[i].visframe = r_visframecount; + return; + } + + vis = Mod_ClusterPVS(r_viewcluster, r_worldmodel); + // may have to combine two clusters because of solid water boundaries + if (r_viewcluster2 != r_viewcluster) + { + // memcpy (fatvis, vis, (r_worldmodel.numleafs+7)/8); + System.arraycopy(vis, 0, fatvis, 0, (r_worldmodel.numleafs+7) / 8); + vis = Mod_ClusterPVS(r_viewcluster2, r_worldmodel); + c = (r_worldmodel.numleafs + 31) / 32; + int k = 0; + for (i=0 ; i<c ; i++) { + fatvis[k] |= vis[k++]; + fatvis[k] |= vis[k++]; + fatvis[k] |= vis[k++]; + fatvis[k] |= vis[k++]; + } + + vis = fatvis; + } + + for ( i=0; i < r_worldmodel.numleafs; i++) + { + leaf = r_worldmodel.leafs[i]; + cluster = leaf.cluster; + if (cluster == -1) + continue; + if (((vis[cluster>>3] & 0xFF) & (1 << (cluster & 7))) != 0) + { + node = (mnode_t)leaf; + do + { + if (node.visframe == r_visframecount) + break; + node.visframe = r_visframecount; + node = node.parent; + } while (node != null); + } + } + } + + + + /* + ============================================================================= + + LIGHTMAP ALLOCATION + + ============================================================================= + */ + + void LM_InitBlock() + { + Arrays.fill(gl_lms.allocated, 0); + } + + void LM_UploadBlock( boolean dynamic ) + { + int texture; + int height = 0; + + if ( dynamic ) + { + texture = 0; + } + else + { + texture = gl_lms.current_lightmap_texture; + } + + GL_Bind( gl_state.lightmap_textures + texture ); + gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); + gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); + + if ( dynamic ) + { + int i; + + for ( i = 0; i < BLOCK_WIDTH; i++ ) + { + if ( gl_lms.allocated[i] > height ) + height = gl_lms.allocated[i]; + } + + gl.glTexSubImage2D( GL.GL_TEXTURE_2D, + 0, + 0, 0, + BLOCK_WIDTH, height, + GL_LIGHTMAP_FORMAT, + GL.GL_UNSIGNED_BYTE, + gl_lms.lightmap_buffer ); + } + else + { + gl.glTexImage2D( GL.GL_TEXTURE_2D, + 0, + gl_lms.internal_format, + BLOCK_WIDTH, BLOCK_HEIGHT, + 0, + GL_LIGHTMAP_FORMAT, + GL.GL_UNSIGNED_BYTE, + gl_lms.lightmap_buffer ); + if ( ++gl_lms.current_lightmap_texture == MAX_LIGHTMAPS ) + ri.Sys_Error( Defines.ERR_DROP, "LM_UploadBlock() - MAX_LIGHTMAPS exceeded\n" ); + + + //debugLightmap(gl_lms.lightmap_buffer, 128, 128, 4); + + } + } + + // returns a texture number and the position inside it + boolean LM_AllocBlock (int w, int h, pos_t pos) + { + int x = pos.x; + int y = pos.y; + int i, j; + int best, best2; + + best = BLOCK_HEIGHT; + + for (i=0 ; i<BLOCK_WIDTH-w ; i++) + { + best2 = 0; + + for (j=0 ; j<w ; j++) + { + if (gl_lms.allocated[i+j] >= best) + break; + if (gl_lms.allocated[i+j] > best2) + best2 = gl_lms.allocated[i+j]; + } + if (j == w) + { // this is a valid spot + pos.x = x = i; + pos.y = y = best = best2; + } + } + + if (best + h > BLOCK_HEIGHT) + return false; + + for (i=0 ; i<w ; i++) + gl_lms.allocated[x + i] = best + h; + + return true; + } + + /* + ================ + GL_BuildPolygonFromSurface + ================ + */ + void GL_BuildPolygonFromSurface(msurface_t fa) + { + int i, lindex, lnumverts; + medge_t[] pedges; + medge_t r_pedge; + int vertpage; + float[] vec; + float s, t; + glpoly_t poly; + float[] total = {0, 0, 0}; + + // reconstruct the polygon + pedges = currentmodel.edges; + lnumverts = fa.numedges; + vertpage = 0; + + Math3D.VectorClear(total); + // + // draw texture + // + // poly = Hunk_Alloc (sizeof(glpoly_t) + (lnumverts-4) * VERTEXSIZE*sizeof(float)); + poly = new glpoly_t(lnumverts); + + poly.next = fa.polys; + poly.flags = fa.flags; + fa.polys = poly; + poly.numverts = lnumverts; + + for (i=0 ; i<lnumverts ; i++) + { + lindex = currentmodel.surfedges[fa.firstedge + i]; + + if (lindex > 0) + { + r_pedge = pedges[lindex]; + vec = currentmodel.vertexes[r_pedge.v[0]].position; + } + else + { + r_pedge = pedges[-lindex]; + vec = currentmodel.vertexes[r_pedge.v[1]].position; + } + s = Math3D.DotProduct (vec, fa.texinfo.vecs[0]) + fa.texinfo.vecs[0][3]; + s /= fa.texinfo.image.width; + + t = Math3D.DotProduct (vec, fa.texinfo.vecs[1]) + fa.texinfo.vecs[1][3]; + t /= fa.texinfo.image.height; + + Math3D.VectorAdd (total, vec, total); + Math3D.VectorCopy (vec, poly.verts[i]); + poly.verts[i][3] = s; + poly.verts[i][4] = t; + + // + // lightmap texture coordinates + // + s = Math3D.DotProduct (vec, fa.texinfo.vecs[0]) + fa.texinfo.vecs[0][3]; + s -= fa.texturemins[0]; + s += fa.light_s*16; + s += 8; + s /= BLOCK_WIDTH*16; //fa.texinfo.texture.width; + + t = Math3D.DotProduct (vec, fa.texinfo.vecs[1]) + fa.texinfo.vecs[1][3]; + t -= fa.texturemins[1]; + t += fa.light_t*16; + t += 8; + t /= BLOCK_HEIGHT*16; //fa.texinfo.texture.height; + + poly.verts[i][5] = s; + poly.verts[i][6] = t; + } + + poly.numverts = lnumverts; + + } + + /* + ======================== + GL_CreateSurfaceLightmap + ======================== + */ + void GL_CreateSurfaceLightmap(msurface_t surf) + { + int smax, tmax; + ByteBuffer base; + + if ( (surf.flags & (Defines.SURF_DRAWSKY | Defines.SURF_DRAWTURB)) != 0) + return; + + smax = (surf.extents[0]>>4)+1; + tmax = (surf.extents[1]>>4)+1; + + pos_t lightPos = new pos_t(surf.light_s, surf.light_t); + + if ( !LM_AllocBlock( smax, tmax, lightPos ) ) + { + LM_UploadBlock( false ); + LM_InitBlock(); + lightPos = new pos_t(surf.light_s, surf.light_t); + if ( !LM_AllocBlock( smax, tmax, lightPos ) ) + { + ri.Sys_Error( Defines.ERR_FATAL, "Consecutive calls to LM_AllocBlock(" + smax +"," + tmax +") failed\n"); + } + } + + // kopiere die koordinaten zurueck + surf.light_s = lightPos.x; + surf.light_t = lightPos.y; + + surf.lightmaptexturenum = gl_lms.current_lightmap_texture; + + // base = gl_lms.lightmap_buffer; + base = ByteBuffer.wrap(gl_lms.lightmap_buffer); + int basep = (surf.light_t * BLOCK_WIDTH + surf.light_s) * LIGHTMAP_BYTES; + base.position(basep); + + R_SetCacheState( surf ); + R_BuildLightMap(surf, base.slice(), BLOCK_WIDTH * LIGHTMAP_BYTES); + } + + lightstyle_t[] lightstyles; + + /* + ================== + GL_BeginBuildingLightmaps + + ================== + */ + void GL_BeginBuildingLightmaps(model_t m) + { + // static lightstyle_t lightstyles[MAX_LIGHTSTYLES]; + int i; + int[] dummy = new int[128*128]; + + // init lightstyles + if ( lightstyles == null ) { + lightstyles = new lightstyle_t[Defines.MAX_LIGHTSTYLES]; + for (i = 0; i < lightstyles.length; i++) + { + lightstyles[i] = new lightstyle_t(); + } + } + + // memset( gl_lms.allocated, 0, sizeof(gl_lms.allocated) ); + Arrays.fill(gl_lms.allocated, 0); + + r_framecount = 1; // no dlightcache + + GL_EnableMultitexture( true ); + GL_SelectTexture( GL_TEXTURE1); + + /* + ** setup the base lightstyles so the lightmaps won't have to be regenerated + ** the first time they're seen + */ + for (i=0 ; i < Defines.MAX_LIGHTSTYLES ; i++) + { + lightstyles[i].rgb[0] = 1; + lightstyles[i].rgb[1] = 1; + lightstyles[i].rgb[2] = 1; + lightstyles[i].white = 3; + } + r_newrefdef.lightstyles = lightstyles; + + if (gl_state.lightmap_textures == 0) + { + gl_state.lightmap_textures = TEXNUM_LIGHTMAPS; + } + + gl_lms.current_lightmap_texture = 1; + + /* + ** if mono lightmaps are enabled and we want to use alpha + ** blending (a,1-a) then we're likely running on a 3DLabs + ** Permedia2. In a perfect world we'd use a GL_ALPHA lightmap + ** in order to conserve space and maximize bandwidth, however + ** this isn't a perfect world. + ** + ** So we have to use alpha lightmaps, but stored in GL_RGBA format, + ** which means we only get 1/16th the color resolution we should when + ** using alpha lightmaps. If we find another board that supports + ** only alpha lightmaps but that can at least support the GL_ALPHA + ** format then we should change this code to use real alpha maps. + */ + + char format = gl_monolightmap.string.toUpperCase().charAt(0); + + if ( format == 'A' ) + { + gl_lms.internal_format = gl_tex_alpha_format; + } + /* + ** try to do hacked colored lighting with a blended texture + */ + else if ( format == 'C' ) + { + gl_lms.internal_format = gl_tex_alpha_format; + } + else if ( format == 'I' ) + { + gl_lms.internal_format = GL.GL_INTENSITY8; + } + else if ( format == 'L' ) + { + gl_lms.internal_format = GL.GL_LUMINANCE8; + } + else + { + gl_lms.internal_format = gl_tex_solid_format; + } + + /* + ** initialize the dynamic lightmap texture + */ + GL_Bind( gl_state.lightmap_textures + 0 ); + gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); + gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); + gl.glTexImage2D( GL.GL_TEXTURE_2D, + 0, + gl_lms.internal_format, + BLOCK_WIDTH, BLOCK_HEIGHT, + 0, + GL_LIGHTMAP_FORMAT, + GL.GL_UNSIGNED_BYTE, + dummy ); + } + + /* + ======================= + GL_EndBuildingLightmaps + ======================= + */ + void GL_EndBuildingLightmaps() + { + LM_UploadBlock( false ); + GL_EnableMultitexture( false ); + } + + + ImageFrame frame; + + void debugLightmap(byte[] buf, int w, int h, float scale) { + IntBuffer pix = ByteBuffer.wrap(buf).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer(); + + int[] pixel = new int[w * h]; + + pix.get(pixel); + + BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_4BYTE_ABGR); + image.setRGB(0, 0, w, h, pixel, 0, w); + AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(scale, scale), AffineTransformOp.TYPE_NEAREST_NEIGHBOR); + BufferedImage tmp = op.filter(image, null); + + if (frame == null) { + frame = new ImageFrame(null); + frame.show(); + } + frame.showImage(tmp); + + } + +} |