diff options
| author | Carsten Weisse <[email protected]> | 2006-11-21 00:52:51 +0000 |
|---|---|---|
| committer | Carsten Weisse <[email protected]> | 2006-11-21 00:52:51 +0000 |
| commit | 17b95195843d63063d989d6a99893ae6300f5ba5 (patch) | |
| tree | 4ccd4fa9039724687039209c039344f285ef0b16 /src/jake2/render | |
| parent | 6cfce25cd7b75c03ee2fc6b238e68f7e4cabb058 (diff) | |
merge render-refactoring branch into the HEAD
Diffstat (limited to 'src/jake2/render')
62 files changed, 21812 insertions, 11494 deletions
diff --git a/src/jake2/render/Base.java b/src/jake2/render/Base.java new file mode 100644 index 0000000..f828e96 --- /dev/null +++ b/src/jake2/render/Base.java @@ -0,0 +1,191 @@ +/* + * Base.java + * Copyright (C) 2003 + * + * $Id: Base.java,v 1.2 2006-11-21 00:51:22 cawe 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; + +import jake2.client.refexport_t; +import jake2.client.viddef_t; +import jake2.game.cvar_t; +import jake2.render.*; +import jake2.render.opengl.*; + +import java.awt.Dimension; + +/** + * Base + * + * @author dsanders/cwei + */ +public abstract class Base implements QGLConst, RenderAPI { + + public static final int GL_COLOR_INDEX8_EXT = GL_COLOR_INDEX; + + public static final String REF_VERSION = "GL 0.01"; + + // up / down + public static final int PITCH = 0; + + // left / right + public static final int YAW = 1; + + // fall over + public static final int ROLL = 2; + + /* + * skins will be outline flood filled and mip mapped pics and sprites with + * alpha will be outline flood filled pic won't be mip mapped + * + * model skin sprite frame wall texture pic + */ + // enum imagetype_t + public static final int it_skin = 0; + + public static final int it_sprite = 1; + + public static final int it_wall = 2; + + public static final int it_pic = 3; + + public static final int it_sky = 4; + + // enum modtype_t + public static final int mod_bad = 0; + + public static final int mod_brush = 1; + + public static final int mod_sprite = 2; + + public static final int mod_alias = 3; + + public static final int TEXNUM_LIGHTMAPS = 1024; + + public static final int TEXNUM_SCRAPS = 1152; + + public static final int TEXNUM_IMAGES = 1153; + + public static final int MAX_GLTEXTURES = 1024; + + public static final int MAX_LBM_HEIGHT = 480; + + public static final float BACKFACE_EPSILON = 0.01f; + + /* + * * GL config stuff + */ + public static final int GL_RENDERER_VOODOO = 0x00000001; + + public static final int GL_RENDERER_VOODOO2 = 0x00000002; + + public static final int GL_RENDERER_VOODOO_RUSH = 0x00000004; + + public static final int GL_RENDERER_BANSHEE = 0x00000008; + + public static final int GL_RENDERER_3DFX = 0x0000000F; + + public static final int GL_RENDERER_PCX1 = 0x00000010; + + public static final int GL_RENDERER_PCX2 = 0x00000020; + + public static final int GL_RENDERER_PMX = 0x00000040; + + public static final int GL_RENDERER_POWERVR = 0x00000070; + + public static final int GL_RENDERER_PERMEDIA2 = 0x00000100; + + public static final int GL_RENDERER_GLINT_MX = 0x00000200; + + public static final int GL_RENDERER_GLINT_TX = 0x00000400; + + public static final int GL_RENDERER_3DLABS_MISC = 0x00000800; + + public static final int GL_RENDERER_3DLABS = 0x00000F00; + + public static final int GL_RENDERER_REALIZM = 0x00001000; + + public static final int GL_RENDERER_REALIZM2 = 0x00002000; + + public static final int GL_RENDERER_INTERGRAPH = 0x00003000; + + public static final int GL_RENDERER_3DPRO = 0x00004000; + + public static final int GL_RENDERER_REAL3D = 0x00008000; + + public static final int GL_RENDERER_RIVA128 = 0x00010000; + + public static final int GL_RENDERER_DYPIC = 0x00020000; + + public static final int GL_RENDERER_V1000 = 0x00040000; + + public static final int GL_RENDERER_V2100 = 0x00080000; + + public static final int GL_RENDERER_V2200 = 0x00100000; + + public static final int GL_RENDERER_RENDITION = 0x001C0000; + + public static final int GL_RENDERER_O2 = 0x00100000; + + public static final int GL_RENDERER_IMPACT = 0x00200000; + + public static final int GL_RENDERER_RE = 0x00400000; + + public static final int GL_RENDERER_IR = 0x00800000; + + public static final int GL_RENDERER_SGI = 0x00F00000; + + public static final int GL_RENDERER_MCD = 0x01000000; + + public static final int GL_RENDERER_OTHER = 0x80000000; + + // enum rserr_t + public static final int rserr_ok = 0; + + public static final int rserr_invalid_fullscreen = 1; + + public static final int rserr_invalid_mode = 2; + + public static final int rserr_unknown = 3; + + /* + * base members + */ + protected static viddef_t vid = new viddef_t(); + + protected cvar_t vid_fullscreen; + + protected QGL gl; + + protected GLDriver glImpl; + + public void setGLDriver(GLDriver driver) { + glImpl = driver; + gl = (QGL)driver; + } + + public static void setVid(int width, int height) { + vid.width = width; + vid.height = height; + } + +}
\ No newline at end of file diff --git a/src/jake2/render/FastJoglRenderer.java b/src/jake2/render/JoglRenderer.java index 7ec8d7e..8d76d7b 100644 --- a/src/jake2/render/FastJoglRenderer.java +++ b/src/jake2/render/JoglRenderer.java @@ -1,8 +1,8 @@ /* - * FastJoglRenderer.java + * JoglRenderer.java * Copyright (C) 2003 * - * $Id: FastJoglRenderer.java,v 1.4 2004-12-14 00:11:09 hzi Exp $ + * $Id: JoglRenderer.java,v 1.8 2006-11-21 00:51:22 cawe Exp $ */ /* Copyright (C) 1997-2001 Id Software, Inc. @@ -26,30 +26,35 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. package jake2.render; import jake2.Defines; -import jake2.client.*; +import jake2.client.refdef_t; +import jake2.client.refexport_t; import jake2.qcommon.xcommand_t; -import jake2.render.fastjogl.Misc; +import jake2.render.opengl.JoglDriver; import jake2.sys.JOGLKBD; import jake2.sys.KBD; import java.awt.Dimension; /** - * FastJoglRenderer + * JoglRenderer * * @author cwei */ -final class FastJoglRenderer extends Misc implements refexport_t, Ref { - - private JOGLKBD kbd=new JOGLKBD(); - - public static final String DRIVER_NAME = "fastjogl"; - +final class JoglRenderer extends JoglDriver implements refexport_t, Ref { + + public static final String DRIVER_NAME = "jogl"; + + private KBD kbd = new JOGLKBD(); + + // is set from Renderer factory + private RenderAPI impl; + static { - Renderer.register(new FastJoglRenderer()); + Renderer.register(new JoglRenderer()); }; - private FastJoglRenderer() { + private JoglRenderer() { + // singleton } // ============================================================================ @@ -58,15 +63,22 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { // refexport_t (ref.h) // ============================================================================ - /** + + private boolean post_init = false; +/** * @see jake2.client.refexport_t#Init() */ public boolean Init(int vid_xpos, int vid_ypos) { - + // init the OpenGL drivers + impl.setGLDriver(this); // pre init - if (!R_Init(vid_xpos, vid_ypos)) return false; - // calls the R_Init2() internally - updateScreen(); + if (!impl.R_Init(vid_xpos, vid_ypos)) return false; + // calls the R_Init2() internally + updateScreen(new xcommand_t() { + public void execute() { + JoglRenderer.this.post_init = impl.R_Init2(); + } + }); // the result from R_Init2() return post_init; } @@ -75,7 +87,7 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { * @see jake2.client.refexport_t#Shutdown() */ public void Shutdown() { - R_Shutdown(); + impl.R_Shutdown(); } /** @@ -83,14 +95,15 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { */ public void BeginRegistration(String map) { if (contextInUse) { - R_BeginRegistration(map); + impl.R_BeginRegistration(map); return; - } + } + this.name = map; - + updateScreen(new xcommand_t() { public void execute() { - R_BeginRegistration(FastJoglRenderer.this.name); + impl.R_BeginRegistration(JoglRenderer.this.name); } }); } @@ -105,14 +118,14 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { public model_t RegisterModel(String name) { if (contextInUse) - return R_RegisterModel(name); + return impl.R_RegisterModel(name); model = null; this.name = name; updateScreen(new xcommand_t() { public void execute() { - FastJoglRenderer.this.model = R_RegisterModel(FastJoglRenderer.this.name); + JoglRenderer.this.model = impl.R_RegisterModel(JoglRenderer.this.name); } }); return model; @@ -123,14 +136,14 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { */ public image_t RegisterSkin(String name) { if (contextInUse) - return R_RegisterSkin(name); + return impl.R_RegisterSkin(name); this.image = null; this.name = name; updateScreen(new xcommand_t() { public void execute() { - FastJoglRenderer.this.image = R_RegisterSkin(FastJoglRenderer.this.name); + JoglRenderer.this.image = impl.R_RegisterSkin(JoglRenderer.this.name); } }); return image; @@ -143,20 +156,19 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { */ public image_t RegisterPic(String name) { if (contextInUse) - return Draw_FindPic(name); + return impl.Draw_FindPic(name); this.image = null; this.name = name; updateScreen(new xcommand_t() { public void execute() { - FastJoglRenderer.this.image = Draw_FindPic(FastJoglRenderer.this.name); + JoglRenderer.this.image = impl.Draw_FindPic(JoglRenderer.this.name); } }); return image; } - private float[] axis; private float rotate; @@ -165,7 +177,7 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { */ public void SetSky(String name, float rotate, float[] axis) { if (contextInUse) { - R_SetSky(name, rotate, axis); + impl.R_SetSky(name, rotate, axis); return; } @@ -175,10 +187,9 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { updateScreen(new xcommand_t() { public void execute() { - R_SetSky(FastJoglRenderer.this.name, FastJoglRenderer.this.rotate, FastJoglRenderer.this.axis); + impl.R_SetSky(JoglRenderer.this.name, JoglRenderer.this.rotate, JoglRenderer.this.axis); } }); - } /** @@ -186,13 +197,13 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { */ public void EndRegistration() { if (contextInUse) { - R_EndRegistration(); + impl.R_EndRegistration(); return; } updateScreen(new xcommand_t() { public void execute() { - R_EndRegistration(); + impl.R_EndRegistration(); } }); } @@ -201,96 +212,115 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { * @see jake2.client.refexport_t#RenderFrame(jake2.client.refdef_t) */ public void RenderFrame(refdef_t fd) { - R_RenderFrame(fd); + impl.R_RenderFrame(fd); } /** * @see jake2.client.refexport_t#DrawGetPicSize(java.awt.Dimension, java.lang.String) */ public void DrawGetPicSize(Dimension dim, String name) { - Draw_GetPicSize(dim, name); + impl.Draw_GetPicSize(dim, name); } /** * @see jake2.client.refexport_t#DrawPic(int, int, java.lang.String) */ public void DrawPic(int x, int y, String name) { - Draw_Pic(x, y, name); + impl.Draw_Pic(x, y, name); } /** * @see jake2.client.refexport_t#DrawStretchPic(int, int, int, int, java.lang.String) */ public void DrawStretchPic(int x, int y, int w, int h, String name) { - Draw_StretchPic(x, y, w, h, name); + impl.Draw_StretchPic(x, y, w, h, name); } + + private int x, y, num; /** * @see jake2.client.refexport_t#DrawChar(int, int, int) */ public void DrawChar(int x, int y, int num) { - Draw_Char(x, y, num); + if (contextInUse) { + impl.Draw_Char(x, y, num);; + return; + } + + this.x = x; + this.y = y; + this.num = num; + + updateScreen(new xcommand_t() { + public void execute() { + impl.Draw_Char(JoglRenderer.this.x, JoglRenderer.this.y, JoglRenderer.this.num); + } + }); } /** * @see jake2.client.refexport_t#DrawTileClear(int, int, int, int, java.lang.String) */ public void DrawTileClear(int x, int y, int w, int h, String name) { - Draw_TileClear(x, y, w, h, name); + impl.Draw_TileClear(x, y, w, h, name); } /** * @see jake2.client.refexport_t#DrawFill(int, int, int, int, int) */ public void DrawFill(int x, int y, int w, int h, int c) { - Draw_Fill(x, y, w, h, c); + impl.Draw_Fill(x, y, w, h, c); } /** * @see jake2.client.refexport_t#DrawFadeScreen() */ public void DrawFadeScreen() { - Draw_FadeScreen(); + impl.Draw_FadeScreen(); } /** * @see jake2.client.refexport_t#DrawStretchRaw(int, int, int, int, int, int, byte[]) */ public void DrawStretchRaw(int x, int y, int w, int h, int cols, int rows, byte[] data) { - Draw_StretchRaw(x, y, w, h, cols, rows, data); + impl.Draw_StretchRaw(x, y, w, h, cols, rows, data); } /** * @see jake2.client.refexport_t#CinematicSetPalette(byte[]) */ public void CinematicSetPalette(byte[] palette) { - R_SetPalette(palette); + impl.R_SetPalette(palette); } /** * @see jake2.client.refexport_t#BeginFrame(float) */ public void BeginFrame(float camera_separation) { - R_BeginFrame(camera_separation); + impl.R_BeginFrame(camera_separation); } /** * @see jake2.client.refexport_t#EndFrame() */ public void EndFrame() { - GLimp_EndFrame(); + endFrame(); } /** * @see jake2.client.refexport_t#AppActivate(boolean) */ public void AppActivate(boolean activate) { - GLimp_AppActivate(activate); + appActivate(activate); } public int apiVersion() { return Defines.API_VERSION; } + + public KBD getKeyboardHandler() { + return kbd; + } // ============================================================================ // Ref interface @@ -304,12 +334,9 @@ final class FastJoglRenderer extends Misc implements refexport_t, Ref { return DRIVER_NAME; } - public refexport_t GetRefAPI() { + public refexport_t GetRefAPI(RenderAPI renderer) { + this.impl = renderer; return this; } - - public KBD getKeyboardHandler() - { - return kbd; - } + }
\ No newline at end of file diff --git a/src/jake2/render/Jsr231Renderer.java b/src/jake2/render/Jsr231Renderer.java new file mode 100644 index 0000000..0513dcb --- /dev/null +++ b/src/jake2/render/Jsr231Renderer.java @@ -0,0 +1,248 @@ +/* + * Jsr231Renderer.java + * Copyright (C) 2004 + * + * $Id: Jsr231Renderer.java,v 1.2 2006-11-21 00:51:22 cawe 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; + +import jake2.Defines; +import jake2.client.refdef_t; +import jake2.client.refexport_t; +import jake2.render.opengl.Jsr231Driver; +import jake2.sys.JOGLKBD; +import jake2.sys.KBD; + +import java.awt.Dimension; + +/** + * Jsr231Renderer + * + * @author dsanders/cwei + */ +final class Jsr231Renderer extends Jsr231Driver implements refexport_t, Ref { + + public static final String DRIVER_NAME = "jsr231"; + + private KBD kbd = new JOGLKBD(); + + // is set from Renderer factory + private RenderAPI impl; + + static { + Renderer.register(new Jsr231Renderer()); + }; + + private Jsr231Renderer() { + // singleton + } + + // ============================================================================ + // public interface for Renderer implementations + // + // refexport_t (ref.h) + // ============================================================================ + + /** + * @see jake2.client.refexport_t#Init() + */ + public boolean Init(int vid_xpos, int vid_ypos) { + // init the OpenGL drivers + impl.setGLDriver(this); + // pre init + if (!impl.R_Init(vid_xpos, vid_ypos)) return false; + // activates the OpenGL context + activate(); + // post init + return impl.R_Init2(); + } + + /** + * @see jake2.client.refexport_t#Shutdown() + */ + public void Shutdown() { + impl.R_Shutdown(); + } + + /** + * @see jake2.client.refexport_t#BeginRegistration(java.lang.String) + */ + public final void BeginRegistration(String map) { + activate(); + impl.R_BeginRegistration(map); + } + + /** + * @see jake2.client.refexport_t#RegisterModel(java.lang.String) + */ + public final model_t RegisterModel(String name) { + activate(); + return impl.R_RegisterModel(name); + } + + /** + * @see jake2.client.refexport_t#RegisterSkin(java.lang.String) + */ + public final image_t RegisterSkin(String name) { + activate(); + return impl.R_RegisterSkin(name); + } + + /** + * @see jake2.client.refexport_t#RegisterPic(java.lang.String) + */ + public final image_t RegisterPic(String name) { + activate(); + return impl.Draw_FindPic(name); + } + /** + * @see jake2.client.refexport_t#SetSky(java.lang.String, float, float[]) + */ + public final void SetSky(String name, float rotate, float[] axis) { + activate(); + impl.R_SetSky(name, rotate, axis); + } + + /** + * @see jake2.client.refexport_t#EndRegistration() + */ + public final void EndRegistration() { + activate(); + impl.R_EndRegistration(); + } + + /** + * @see jake2.client.refexport_t#RenderFrame(jake2.client.refdef_t) + */ + public final void RenderFrame(refdef_t fd) { + impl.R_RenderFrame(fd); + } + + /** + * @see jake2.client.refexport_t#DrawGetPicSize(java.awt.Dimension, java.lang.String) + */ + public final void DrawGetPicSize(Dimension dim, String name) { + impl.Draw_GetPicSize(dim, name); + } + + /** + * @see jake2.client.refexport_t#DrawPic(int, int, java.lang.String) + */ + public final void DrawPic(int x, int y, String name) { + impl.Draw_Pic(x, y, name); + } + + /** + * @see jake2.client.refexport_t#DrawStretchPic(int, int, int, int, java.lang.String) + */ + public final void DrawStretchPic(int x, int y, int w, int h, String name) { + impl.Draw_StretchPic(x, y, w, h, name); + } + + /** + * @see jake2.client.refexport_t#DrawChar(int, int, int) + */ + public final void DrawChar(int x, int y, int num) { + activate(); + impl.Draw_Char(x, y, num); + } + + /** + * @see jake2.client.refexport_t#DrawTileClear(int, int, int, int, java.lang.String) + */ + public final void DrawTileClear(int x, int y, int w, int h, String name) { + impl.Draw_TileClear(x, y, w, h, name); + } + + /** + * @see jake2.client.refexport_t#DrawFill(int, int, int, int, int) + */ + public final void DrawFill(int x, int y, int w, int h, int c) { + impl.Draw_Fill(x, y, w, h, c); + } + + /** + * @see jake2.client.refexport_t#DrawFadeScreen() + */ + public final void DrawFadeScreen() { + impl.Draw_FadeScreen(); + } + + /** + * @see jake2.client.refexport_t#DrawStretchRaw(int, int, int, int, int, int, byte[]) + */ + public final void DrawStretchRaw(int x, int y, int w, int h, int cols, int rows, byte[] data) { + impl.Draw_StretchRaw(x, y, w, h, cols, rows, data); + } + + /** + * @see jake2.client.refexport_t#CinematicSetPalette(byte[]) + */ + public final void CinematicSetPalette(byte[] palette) { + impl.R_SetPalette(palette); + } + + /** + * @see jake2.client.refexport_t#BeginFrame(float) + */ + public final void BeginFrame(float camera_separation) { + impl.R_BeginFrame(camera_separation); + } + + /** + * @see jake2.client.refexport_t#EndFrame() + */ + public final void EndFrame() { + endFrame(); + } + + /** + * @see jake2.client.refexport_t#AppActivate(boolean) + */ + public final void AppActivate(boolean activate) { + appActivate(activate); + } + + public final int apiVersion() { + return Defines.API_VERSION; + } + + public KBD getKeyboardHandler() { + return kbd; + } + // ============================================================================ + // Ref interface + // ============================================================================ + + public final String getName() { + return DRIVER_NAME; + } + + public final String toString() { + return DRIVER_NAME; + } + + public final refexport_t GetRefAPI(RenderAPI renderer) { + this.impl = renderer; + return this; + } +}
\ No newline at end of file diff --git a/src/jake2/render/LWJGLRenderer.java b/src/jake2/render/LwjglRenderer.java index a893be9..3cf5b0b 100644 --- a/src/jake2/render/LWJGLRenderer.java +++ b/src/jake2/render/LwjglRenderer.java @@ -1,8 +1,8 @@ /* - * LWJGLRenderer.java + * LwjglRenderer.java * Copyright (C) 2004 * - * $Id: LWJGLRenderer.java,v 1.3 2004-12-20 21:49:14 cawe Exp $ + * $Id: LwjglRenderer.java,v 1.2 2006-11-21 00:51:22 cawe Exp $ */ /* Copyright (C) 1997-2001 Id Software, Inc. @@ -27,28 +27,32 @@ package jake2.render; import jake2.Defines; import jake2.client.*; -import jake2.render.lwjgl.Misc; -import jake2.sys.KBD; -import jake2.sys.LWJGLKBD; +import jake2.qcommon.xcommand_t; +import jake2.render.opengl.LwjglDriver; +import jake2.sys.*; import java.awt.Dimension; +import java.awt.DisplayMode; /** - * LWJGLRenderer + * LwjglRenderer * * @author dsanders/cwei */ -final class LWJGLRenderer extends Misc implements refexport_t, Ref { - - private LWJGLKBD kbd=new LWJGLKBD(); - - public static final String DRIVER_NAME = "lwjgl"; +final class LwjglRenderer extends LwjglDriver implements refexport_t, Ref { + public static final String DRIVER_NAME = "lwjgl"; + + private KBD kbd = new LWJGLKBD(); + + // is set from Renderer factory + private RenderAPI impl; + static { - Renderer.register(new LWJGLRenderer()); + Renderer.register(new LwjglRenderer()); }; - private LWJGLRenderer() { + private LwjglRenderer() { } // ============================================================================ @@ -61,159 +65,165 @@ final class LWJGLRenderer extends Misc implements refexport_t, Ref { * @see jake2.client.refexport_t#Init() */ public boolean Init(int vid_xpos, int vid_ypos) { + // init the OpenGL drivers + impl.setGLDriver(this); // pre init - if (!R_Init(vid_xpos, vid_ypos)) return false; + if (!impl.R_Init(vid_xpos, vid_ypos)) return false; // post init - boolean ok = R_Init2(); - if (!ok) { - VID.Printf(Defines.PRINT_ALL, "Missing multi-texturing for LWJGL renderer\n"); - } - return ok; + return impl.R_Init2(); } /** * @see jake2.client.refexport_t#Shutdown() */ public void Shutdown() { - R_Shutdown(); + impl.R_Shutdown(); } /** * @see jake2.client.refexport_t#BeginRegistration(java.lang.String) */ public final void BeginRegistration(String map) { - R_BeginRegistration(map); + impl.R_BeginRegistration(map); } /** * @see jake2.client.refexport_t#RegisterModel(java.lang.String) */ public final model_t RegisterModel(String name) { - return R_RegisterModel(name); + return impl.R_RegisterModel(name); } /** * @see jake2.client.refexport_t#RegisterSkin(java.lang.String) */ public final image_t RegisterSkin(String name) { - return R_RegisterSkin(name); + return impl.R_RegisterSkin(name); } /** * @see jake2.client.refexport_t#RegisterPic(java.lang.String) */ public final image_t RegisterPic(String name) { - return Draw_FindPic(name); + return impl.Draw_FindPic(name); } /** * @see jake2.client.refexport_t#SetSky(java.lang.String, float, float[]) */ public final void SetSky(String name, float rotate, float[] axis) { - R_SetSky(name, rotate, axis); + impl.R_SetSky(name, rotate, axis); } /** * @see jake2.client.refexport_t#EndRegistration() */ public final void EndRegistration() { - R_EndRegistration(); + impl.R_EndRegistration(); } /** * @see jake2.client.refexport_t#RenderFrame(jake2.client.refdef_t) */ public final void RenderFrame(refdef_t fd) { - R_RenderFrame(fd); + impl.R_RenderFrame(fd); } /** * @see jake2.client.refexport_t#DrawGetPicSize(java.awt.Dimension, java.lang.String) */ public final void DrawGetPicSize(Dimension dim, String name) { - Draw_GetPicSize(dim, name); + impl.Draw_GetPicSize(dim, name); } /** * @see jake2.client.refexport_t#DrawPic(int, int, java.lang.String) */ public final void DrawPic(int x, int y, String name) { - Draw_Pic(x, y, name); + impl.Draw_Pic(x, y, name); } /** * @see jake2.client.refexport_t#DrawStretchPic(int, int, int, int, java.lang.String) */ public final void DrawStretchPic(int x, int y, int w, int h, String name) { - Draw_StretchPic(x, y, w, h, name); + impl.Draw_StretchPic(x, y, w, h, name); } /** * @see jake2.client.refexport_t#DrawChar(int, int, int) */ public final void DrawChar(int x, int y, int num) { - Draw_Char(x, y, num); + impl.Draw_Char(x, y, num); } /** * @see jake2.client.refexport_t#DrawTileClear(int, int, int, int, java.lang.String) */ public final void DrawTileClear(int x, int y, int w, int h, String name) { - Draw_TileClear(x, y, w, h, name); + impl.Draw_TileClear(x, y, w, h, name); } /** * @see jake2.client.refexport_t#DrawFill(int, int, int, int, int) */ public final void DrawFill(int x, int y, int w, int h, int c) { - Draw_Fill(x, y, w, h, c); + impl.Draw_Fill(x, y, w, h, c); } /** * @see jake2.client.refexport_t#DrawFadeScreen() */ public final void DrawFadeScreen() { - Draw_FadeScreen(); + impl.Draw_FadeScreen(); } /** * @see jake2.client.refexport_t#DrawStretchRaw(int, int, int, int, int, int, byte[]) */ public final void DrawStretchRaw(int x, int y, int w, int h, int cols, int rows, byte[] data) { - Draw_StretchRaw(x, y, w, h, cols, rows, data); + impl.Draw_StretchRaw(x, y, w, h, cols, rows, data); } /** * @see jake2.client.refexport_t#CinematicSetPalette(byte[]) */ public final void CinematicSetPalette(byte[] palette) { - R_SetPalette(palette); + impl.R_SetPalette(palette); } /** * @see jake2.client.refexport_t#BeginFrame(float) */ public final void BeginFrame(float camera_separation) { - R_BeginFrame(camera_separation); + impl.R_BeginFrame(camera_separation); } /** * @see jake2.client.refexport_t#EndFrame() */ public final void EndFrame() { - GLimp_EndFrame(); + endFrame(); +/* try { + Thread.sleep(1); + } catch (InterruptedException e) { + }*/ } /** * @see jake2.client.refexport_t#AppActivate(boolean) */ public final void AppActivate(boolean activate) { - GLimp_AppActivate(activate); + appActivate(activate); } public final int apiVersion() { return Defines.API_VERSION; } + + public KBD getKeyboardHandler() { + return kbd; + } // ============================================================================ // Ref interface @@ -227,9 +237,8 @@ final class LWJGLRenderer extends Misc implements refexport_t, Ref { return DRIVER_NAME; } - public final refexport_t GetRefAPI() { + public final refexport_t GetRefAPI(RenderAPI renderer) { + this.impl = renderer; return this; } - - public final KBD getKeyboardHandler() { return kbd; } }
\ No newline at end of file diff --git a/src/jake2/render/Ref.java b/src/jake2/render/Ref.java index 568f709..ecc0461 100644 --- a/src/jake2/render/Ref.java +++ b/src/jake2/render/Ref.java @@ -2,7 +2,7 @@ * Ref.java * Copyright (C) 2003 * - * $Id: Ref.java,v 1.2 2004-07-16 10:11:34 cawe Exp $ + * $Id: Ref.java,v 1.3 2006-11-21 00:51:22 cawe Exp $ */ /* Copyright (C) 1997-2001 Id Software, Inc. @@ -34,9 +34,6 @@ import jake2.client.refexport_t; */ public interface Ref { - // ============================================================================ - // extensions (cwei) - // ============================================================================ - refexport_t GetRefAPI(); + refexport_t GetRefAPI(RenderAPI renderer); String getName(); } diff --git a/src/jake2/render/RenderAPI.java b/src/jake2/render/RenderAPI.java new file mode 100644 index 0000000..6bf869b --- /dev/null +++ b/src/jake2/render/RenderAPI.java @@ -0,0 +1,52 @@ +package jake2.render; + +import jake2.client.refdef_t; +import jake2.render.opengl.GLDriver; + +import java.awt.Dimension; + +public interface RenderAPI { + + void setGLDriver(GLDriver impl); + + boolean R_Init(int vid_xpos, int vid_ypos); + + boolean R_Init2(); + + void R_Shutdown(); + + void R_BeginRegistration(String map); + + model_t R_RegisterModel(String name); + + image_t R_RegisterSkin(String name); + + image_t Draw_FindPic(String name); + + void R_SetSky(String name, float rotate, float[] axis); + + void R_EndRegistration(); + + void R_RenderFrame(refdef_t fd); + + void Draw_GetPicSize(Dimension dim, String name); + + void Draw_Pic(int x, int y, String name); + + void Draw_StretchPic(int x, int y, int w, int h, String name); + + void Draw_Char(int x, int y, int num); + + void Draw_TileClear(int x, int y, int w, int h, String name); + + void Draw_Fill(int x, int y, int w, int h, int c); + + void Draw_FadeScreen(); + + void Draw_StretchRaw(int x, int y, int w, int h, int cols, int rows, + byte[] data); + + void R_SetPalette(byte[] palette); + + void R_BeginFrame(float camera_separation); +} diff --git a/src/jake2/render/Renderer.java b/src/jake2/render/Renderer.java index 6141d0c..3e48ac3 100644 --- a/src/jake2/render/Renderer.java +++ b/src/jake2/render/Renderer.java @@ -2,7 +2,7 @@ * Renderer.java * Copyright (C) 2003 * - * $Id: Renderer.java,v 1.6 2005-01-12 00:37:13 cawe Exp $ + * $Id: Renderer.java,v 1.7 2006-11-21 00:51:22 cawe Exp $ */ /* Copyright (C) 1997-2001 Id Software, Inc. @@ -25,39 +25,42 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ package jake2.render; -import java.util.Vector; - import jake2.client.refexport_t; +import java.util.Vector; + /** * Renderer * * @author cwei */ public class Renderer { + + static RenderAPI fastRenderer = new jake2.render.fast.Misc(); + static RenderAPI basicRenderer = new jake2.render.basic.Misc(); static Vector drivers = new Vector(3); static { try { - try { - Class.forName("net.java.games.jogl.GL"); - Class.forName("jake2.render.JoglRenderer"); - } catch (ClassNotFoundException e) { - // ignore the jogl drivers if runtime not in classpath - } - try { + try { + Class.forName("net.java.games.jogl.GL"); + Class.forName("jake2.render.JoglRenderer"); + } catch (ClassNotFoundException e) { + // ignore the fastjogl drivers if runtime not in classpath + } + try { Class.forName("org.lwjgl.opengl.GL11"); - Class.forName("jake2.render.LWJGLRenderer"); + Class.forName("jake2.render.LwjglRenderer"); } catch (ClassNotFoundException e) { // ignore the lwjgl driver if runtime not in classpath } - try { - Class.forName("net.java.games.jogl.GL"); - Class.forName("jake2.render.FastJoglRenderer"); - } catch (ClassNotFoundException e) { - // ignore the fastjogl drivers if runtime not in classpath - } + try { + Class.forName("javax.media.opengl.GL"); + Class.forName("jake2.render.Jsr231Renderer"); + } catch (ClassNotFoundException e) { + // ignore the jogl drivers if runtime not in classpath + } } catch (Throwable e) { e.printStackTrace(); } @@ -72,18 +75,26 @@ public class Renderer { } } - /** + /** + * Factory method to get the Renderer implementation. + * @return refexport_t (Renderer singleton) + */ + public static refexport_t getDriver(String driverName) { + return getDriver(driverName, true); + } + + /** * Factory method to get the Renderer implementation. * @return refexport_t (Renderer singleton) */ - public static refexport_t getDriver(String driverName) { + public static refexport_t getDriver(String driverName, boolean fast) { // find a driver Ref driver = null; int count = drivers.size(); for (int i = 0; i < count; i++) { driver = (Ref) drivers.get(i); if (driver.getName().equals(driverName)) { - return driver.GetRefAPI(); + return driver.GetRefAPI((fast) ? fastRenderer : basicRenderer); } } // null if driver not found @@ -107,4 +118,5 @@ public class Renderer { } return names; } + }
\ No newline at end of file diff --git a/src/jake2/render/common/Anorms.java b/src/jake2/render/basic/Anorms.java index e6b9006..39880cf 100644 --- a/src/jake2/render/common/Anorms.java +++ b/src/jake2/render/basic/Anorms.java @@ -2,7 +2,7 @@ * Anorms.java * Copyright (C) 2003 * - * $Id: Anorms.java,v 1.1 2006-10-31 13:06:32 salomo Exp $ + * $Id: Anorms.java,v 1.2 2006-11-21 00:50:46 cawe Exp $ */ /* Copyright (C) 1997-2001 Id Software, Inc. @@ -23,17 +23,16 @@ 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.common; +package jake2.render.basic; /** * Anorms * * @author cwei */ -public class Anorms -{ +public interface Anorms { - public static final float[][] VERTEXNORMALS = { + final float[][] VERTEXNORMALS = { {-0.525731f, 0.000000f, 0.850651f}, {-0.442863f, 0.238856f, 0.864188f}, {-0.295242f, 0.000000f, 0.955423f}, @@ -198,7 +197,7 @@ public class Anorms {-0.688191f, -0.587785f, -0.425325f} }; - public static final float[][] VERTEXNORMAL_DOTS = { + final float[][] VERTEXNORMAL_DOTS = { {1.23f,1.30f,1.47f,1.35f,1.56f,1.71f,1.37f,1.38f,1.59f,1.60f,1.79f,1.97f,1.88f,1.92f,1.79f,1.02f,0.93f,1.07f,0.82f,0.87f,0.88f,0.94f,0.96f,1.14f,1.11f,0.82f,0.83f,0.89f,0.89f,0.86f,0.94f,0.91f,1.00f,1.21f,0.98f,1.48f,1.30f,1.57f,0.96f,1.07f,1.14f,1.60f,1.61f,1.40f,1.37f,1.72f,1.78f,1.79f,1.93f,1.99f,1.90f,1.68f,1.71f,1.86f,1.60f,1.68f,1.78f,1.86f,1.93f,1.99f,1.97f,1.44f,1.22f,1.49f,0.93f,0.99f,0.99f,1.23f,1.22f,1.44f,1.49f,0.89f,0.89f,0.97f,0.91f,0.98f,1.19f,0.82f,0.76f,0.82f,0.71f,0.72f,0.73f,0.76f,0.79f,0.86f,0.83f,0.72f,0.76f,0.76f,0.89f,0.82f,0.89f,0.82f,0.89f,0.91f,0.83f,0.96f,1.14f,0.97f,1.40f,1.19f,0.98f,0.94f,1.00f,1.07f,1.37f,1.21f,1.48f,1.30f,1.57f,1.61f,1.37f,0.86f,0.83f,0.91f,0.82f,0.82f,0.88f,0.89f,0.96f,1.14f,0.98f,0.87f,0.93f,0.94f,1.02f,1.30f,1.07f,1.35f,1.38f,1.11f,1.56f,1.92f,1.79f,1.79f,1.59f,1.60f,1.72f,1.90f,1.79f,0.80f,0.85f,0.79f,0.93f,0.80f,0.85f,0.77f,0.74f,0.72f,0.77f,0.74f,0.72f,0.70f,0.70f,0.71f,0.76f,0.73f,0.79f,0.79f,0.73f,0.76f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, {1.26f,1.26f,1.48f,1.23f,1.50f,1.71f,1.14f,1.19f,1.38f,1.46f,1.64f,1.94f,1.87f,1.84f,1.71f,1.02f,0.92f,1.00f,0.79f,0.85f,0.84f,0.91f,0.90f,0.98f,0.99f,0.77f,0.77f,0.83f,0.82f,0.79f,0.86f,0.84f,0.92f,0.99f,0.91f,1.24f,1.03f,1.33f,0.88f,0.94f,0.97f,1.41f,1.39f,1.18f,1.11f,1.51f,1.61f,1.59f,1.80f,1.91f,1.76f,1.54f,1.65f,1.76f,1.70f,1.70f,1.85f,1.85f,1.97f,1.99f,1.93f,1.28f,1.09f,1.39f,0.92f,0.97f,0.99f,1.18f,1.26f,1.52f,1.48f,0.83f,0.85f,0.90f,0.88f,0.93f,1.00f,0.77f,0.73f,0.78f,0.72f,0.71f,0.74f,0.75f,0.79f,0.86f,0.81f,0.75f,0.81f,0.79f,0.96f,0.88f,0.94f,0.86f,0.93f,0.92f,0.85f,1.08f,1.33f,1.05f,1.55f,1.31f,1.01f,1.05f,1.27f,1.31f,1.60f,1.47f,1.70f,1.54f,1.76f,1.76f,1.57f,0.93f,0.90f,0.99f,0.88f,0.88f,0.95f,0.97f,1.11f,1.39f,1.20f,0.92f,0.97f,1.01f,1.10f,1.39f,1.22f,1.51f,1.58f,1.32f,1.64f,1.97f,1.85f,1.91f,1.77f,1.74f,1.88f,1.99f,1.91f,0.79f,0.86f,0.80f,0.94f,0.84f,0.88f,0.74f,0.74f,0.71f,0.82f,0.77f,0.76f,0.70f,0.73f,0.72f,0.73f,0.70f,0.74f,0.85f,0.77f,0.82f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, {1.34f,1.27f,1.53f,1.17f,1.46f,1.71f,0.98f,1.05f,1.20f,1.34f,1.48f,1.86f,1.82f,1.71f,1.62f,1.09f,0.94f,0.99f,0.79f,0.85f,0.82f,0.90f,0.87f,0.93f,0.96f,0.76f,0.74f,0.79f,0.76f,0.74f,0.79f,0.78f,0.85f,0.92f,0.85f,1.00f,0.93f,1.06f,0.81f,0.86f,0.89f,1.16f,1.12f,0.97f,0.95f,1.28f,1.38f,1.35f,1.60f,1.77f,1.57f,1.33f,1.50f,1.58f,1.69f,1.63f,1.82f,1.74f,1.91f,1.92f,1.80f,1.04f,0.97f,1.21f,0.90f,0.93f,0.97f,1.05f,1.21f,1.48f,1.37f,0.77f,0.80f,0.84f,0.85f,0.88f,0.92f,0.73f,0.71f,0.74f,0.74f,0.71f,0.75f,0.73f,0.79f,0.84f,0.78f,0.79f,0.86f,0.81f,1.05f,0.94f,0.99f,0.90f,0.95f,0.92f,0.86f,1.24f,1.44f,1.14f,1.59f,1.34f,1.02f,1.27f,1.50f,1.49f,1.80f,1.69f,1.86f,1.72f,1.87f,1.80f,1.69f,1.00f,0.98f,1.23f,0.95f,0.96f,1.09f,1.16f,1.37f,1.63f,1.46f,0.99f,1.10f,1.25f,1.24f,1.51f,1.41f,1.67f,1.77f,1.55f,1.72f,1.95f,1.89f,1.98f,1.91f,1.86f,1.97f,1.99f,1.94f,0.81f,0.89f,0.85f,0.98f,0.90f,0.94f,0.75f,0.78f,0.73f,0.89f,0.83f,0.82f,0.72f,0.77f,0.76f,0.72f,0.70f,0.71f,0.91f,0.83f,0.89f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, diff --git a/src/jake2/render/basic/Draw.java b/src/jake2/render/basic/Draw.java new file mode 100644 index 0000000..a4347cb --- /dev/null +++ b/src/jake2/render/basic/Draw.java @@ -0,0 +1,408 @@ +/* + * Draw.java + * Copyright (C) 2003 + * + * $Id: Draw.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.client.VID; +import jake2.qcommon.Com; +import jake2.render.image_t; +import jake2.util.Lib; + +import java.awt.Dimension; +import java.nio.ByteBuffer; +import java.nio.IntBuffer; + +/** + * Draw + * (gl_draw.c) + * + * @author cwei + */ +public abstract class Draw extends Image { + + /* + =============== + Draw_InitLocal + =============== + */ + void Draw_InitLocal() { + // load console characters (don't bilerp characters) + draw_chars = GL_FindImage("pics/conchars.pcx", it_pic); + GL_Bind(draw_chars.texnum); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + /* + ================ + Draw_Char + + Draws one 8*8 graphics character with 0 being transparent. + It can be clipped to the top of the screen to allow the console to be + smoothly scrolled off. + ================ + */ + public void Draw_Char(int x, int y, int num) { + + num &= 255; + + if ( (num&127) == 32 ) return; // space + + if (y <= -8) return; // totally off screen + + int row = num>>4; + int col = num&15; + + float frow = row*0.0625f; + float fcol = col*0.0625f; + float size = 0.0625f; + + GL_Bind(draw_chars.texnum); + + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (fcol, frow); + gl.glVertex2f (x, y); + gl.glTexCoord2f (fcol + size, frow); + gl.glVertex2f (x+8, y); + gl.glTexCoord2f (fcol + size, frow + size); + gl.glVertex2f (x+8, y+8); + gl.glTexCoord2f (fcol, frow + size); + gl.glVertex2f (x, y+8); + gl.glEnd (); + } + + + /* + ============= + Draw_FindPic + ============= + */ + public image_t Draw_FindPic(String name) { + image_t image = null; + String fullname; + + if (!name.startsWith("/") && !name.startsWith("\\")) + { + fullname = "pics/" + name + ".pcx"; + image = GL_FindImage(fullname, it_pic); + } else { + image = GL_FindImage(name.substring(1), it_pic); + } + return image; + } + + + /* + ============= + Draw_GetPicSize + ============= + */ + public void Draw_GetPicSize(Dimension dim, String pic) { + + image_t image = Draw_FindPic(pic); + dim.width = (image != null) ? image.width : -1; + dim.height = (image != null) ? image.height : -1; + } + + /* + ============= + Draw_StretchPic + ============= + */ + public void Draw_StretchPic (int x, int y, int w, int h, String pic) { + + image_t image; + + image = Draw_FindPic(pic); + if (image == null) + { + VID.Printf (Defines.PRINT_ALL, "Can't find pic: " + pic +'\n'); + return; + } + + if (scrap_dirty) + Scrap_Upload(); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0) ) && !image.has_alpha) + gl.glDisable(GL_ALPHA_TEST); + + GL_Bind(image.texnum); + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (image.sl, image.tl); + gl.glVertex2f (x, y); + gl.glTexCoord2f (image.sh, image.tl); + gl.glVertex2f (x+w, y); + gl.glTexCoord2f (image.sh, image.th); + gl.glVertex2f (x+w, y+h); + gl.glTexCoord2f (image.sl, image.th); + gl.glVertex2f (x, y+h); + gl.glEnd (); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) !=0 ) ) && !image.has_alpha) + gl.glEnable(GL_ALPHA_TEST); + } + + + /* + ============= + Draw_Pic + ============= + */ + public void Draw_Pic(int x, int y, String pic) + { + image_t image; + + image = Draw_FindPic(pic); + if (image == null) + { + VID.Printf(Defines.PRINT_ALL, "Can't find pic: " +pic + '\n'); + return; + } + if (scrap_dirty) + Scrap_Upload(); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glDisable (GL_ALPHA_TEST); + + GL_Bind(image.texnum); + + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (image.sl, image.tl); + gl.glVertex2f (x, y); + gl.glTexCoord2f (image.sh, image.tl); + gl.glVertex2f (x+image.width, y); + gl.glTexCoord2f (image.sh, image.th); + gl.glVertex2f (x+image.width, y+image.height); + gl.glTexCoord2f (image.sl, image.th); + gl.glVertex2f (x, y+image.height); + gl.glEnd (); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glEnable (GL_ALPHA_TEST); + } + + /* + ============= + Draw_TileClear + + This repeats a 64*64 tile graphic to fill the screen around a sized down + refresh window. + ============= + */ + public void Draw_TileClear(int x, int y, int w, int h, String pic) { + image_t image; + + image = Draw_FindPic(pic); + if (image == null) + { + VID.Printf(Defines.PRINT_ALL, "Can't find pic: " + pic + '\n'); + return; + } + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glDisable(GL_ALPHA_TEST); + + GL_Bind(image.texnum); + gl.glBegin (GL_QUADS); + gl.glTexCoord2f(x/64.0f, y/64.0f); + gl.glVertex2f (x, y); + gl.glTexCoord2f( (x+w)/64.0f, y/64.0f); + gl.glVertex2f(x+w, y); + gl.glTexCoord2f( (x+w)/64.0f, (y+h)/64.0f); + gl.glVertex2f(x+w, y+h); + gl.glTexCoord2f( x/64.0f, (y+h)/64.0f ); + gl.glVertex2f (x, y+h); + gl.glEnd (); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glEnable(GL_ALPHA_TEST); + } + + + /* + ============= + Draw_Fill + + Fills a box of pixels with a single color + ============= + */ + public 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"); + + gl.glDisable(GL_TEXTURE_2D); + + int color = d_8to24table[colorIndex]; + + gl.glColor3ub( + (byte)((color >> 0) & 0xff), // r + (byte)((color >> 8) & 0xff), // g + (byte)((color >> 16) & 0xff) // b + ); + + gl.glBegin (GL_QUADS); + + gl.glVertex2f(x,y); + gl.glVertex2f(x+w, y); + gl.glVertex2f(x+w, y+h); + gl.glVertex2f(x, y+h); + + gl.glEnd(); + gl.glColor3f(1,1,1); + gl.glEnable(GL_TEXTURE_2D); + } + +// ============================================================================= + + /* + ================ + Draw_FadeScreen + ================ + */ + public void Draw_FadeScreen() { + gl.glEnable(GL_BLEND); + gl.glDisable(GL_TEXTURE_2D); + gl.glColor4f(0, 0, 0, 0.8f); + gl.glBegin(GL_QUADS); + + gl.glVertex2f(0,0); + gl.glVertex2f(vid.width, 0); + gl.glVertex2f(vid.width, vid.height); + gl.glVertex2f(0, vid.height); + + gl.glEnd(); + gl.glColor4f(1,1,1,1); + gl.glEnable(GL_TEXTURE_2D); + gl.glDisable(GL_BLEND); + } + +// ==================================================================== + IntBuffer image32=Lib.newIntBuffer(256*256); + ByteBuffer image8=Lib.newByteBuffer(256*256); + + /* + ============= + Draw_StretchRaw + ============= + */ + public 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; + 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 ) + { + 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; + } + } + gl.glTexImage2D (GL_TEXTURE_2D, 0, gl_tex_solid_format, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, image32); + } + else + { + 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; + } + } + + gl.glTexImage2D( GL_TEXTURE_2D, + 0, + GL_COLOR_INDEX8_EXT, + 256, 256, + 0, + GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, + image8 ); + } + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + if ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) + gl.glDisable (GL_ALPHA_TEST); + + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (0, 0); + gl.glVertex2f (x, y); + gl.glTexCoord2f (1, 0); + gl.glVertex2f (x+w, y); + gl.glTexCoord2f (1, t); + gl.glVertex2f (x+w, y+h); + gl.glTexCoord2f (0, t); + gl.glVertex2f (x, y+h); + gl.glEnd (); + + if ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) + gl.glEnable (GL_ALPHA_TEST); + } + +} diff --git a/src/jake2/render/basic/Image.java b/src/jake2/render/basic/Image.java new file mode 100644 index 0000000..cc7f09b --- /dev/null +++ b/src/jake2/render/basic/Image.java @@ -0,0 +1,1664 @@ +/* + * Image.java + * Copyright (C) 2003 + * + * $Id: Image.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.client.VID; +import jake2.client.particle_t; +import jake2.game.cvar_t; +import jake2.qcommon.Com; +import jake2.qcommon.Cvar; +import jake2.qcommon.FS; +import jake2.qcommon.longjmpException; +import jake2.qcommon.qfiles; +import jake2.render.image_t; +import jake2.util.Lib; +import jake2.util.Vargs; + +import java.awt.Dimension; +import java.awt.geom.AffineTransform; +import java.awt.image.AffineTransformOp; +import java.awt.image.BufferedImage; +import java.nio.*; +import java.util.Arrays; + + +/** + * Image + * + * @author cwei + */ +public abstract class Image extends Main { + + image_t draw_chars; + + image_t[] gltextures = new image_t[MAX_GLTEXTURES]; + + //Map gltextures = new Hashtable(MAX_GLTEXTURES); // image_t + int numgltextures; + + int base_textureid; // gltextures[i] = base_textureid+i + + byte[] intensitytable = new byte[256]; + + byte[] gammatable = new byte[256]; + + cvar_t intensity; + + // + // qboolean GL_Upload8 (byte *data, int width, int height, qboolean mipmap, + // qboolean is_sky ); + // qboolean GL_Upload32 (unsigned *data, int width, int height, qboolean + // mipmap); + // + + int gl_solid_format = 3; + + int gl_alpha_format = 4; + + int gl_tex_solid_format = 3; + + int gl_tex_alpha_format = 4; + + int gl_filter_min = GL_LINEAR_MIPMAP_NEAREST; + + int gl_filter_max = GL_LINEAR; + + Image() { + // init the texture cache + for (int i = 0; i < gltextures.length; i++) { + gltextures[i] = new image_t(i); + } + numgltextures = 0; + } + + void GL_SetTexturePalette(int[] palette) { + + assert (palette != null && palette.length == 256) : "int palette[256] bug"; + + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f) { + ByteBuffer temptable = Lib.newByteBuffer(768); + for (int i = 0; i < 256; i++) { + temptable.put(i * 3 + 0, (byte) ((palette[i] >> 0) & 0xff)); + temptable.put(i * 3 + 1, (byte) ((palette[i] >> 8) & 0xff)); + temptable.put(i * 3 + 2, (byte) ((palette[i] >> 16) & 0xff)); + } + + gl.glColorTable(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, temptable); + } + } + + void GL_EnableMultitexture(boolean enable) { + if (!qglSelectTextureSGIS && !qglActiveTextureARB) + return; + + if (enable) { + GL_SelectTexture(GL_TEXTURE1); + gl.glEnable(GL_TEXTURE_2D); + GL_TexEnv(GL_REPLACE); + } else { + GL_SelectTexture(GL_TEXTURE1); + gl.glDisable(GL_TEXTURE_2D); + GL_TexEnv(GL_REPLACE); + } + GL_SelectTexture(GL_TEXTURE0); + GL_TexEnv(GL_REPLACE); + } + + void GL_SelectTexture(int texture /* GLenum */) { + int tmu; + + if (!qglSelectTextureSGIS && !qglActiveTextureARB) + return; + + if (texture == GL_TEXTURE0) { + tmu = 0; + } else { + tmu = 1; + } + + if (tmu == gl_state.currenttmu) { + return; + } + + gl_state.currenttmu = tmu; + + if (qglSelectTextureSGIS) { + // TODO handle this: gl.glSelectTextureSGIS(texture); + gl.glActiveTextureARB(texture); + } else if (qglActiveTextureARB) { + gl.glActiveTextureARB(texture); + gl.glClientActiveTextureARB(texture); + } + } + + int[] lastmodes = { -1, -1 }; + + void GL_TexEnv(int mode /* GLenum */ + ) { + + if (mode != lastmodes[gl_state.currenttmu]) { + gl.glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode); + lastmodes[gl_state.currenttmu] = mode; + } + } + + void GL_Bind(int texnum) { + + if ((gl_nobind.value != 0) && (draw_chars != null)) { + // performance evaluation option + texnum = draw_chars.texnum; + } + if (gl_state.currenttextures[gl_state.currenttmu] == texnum) + return; + + gl_state.currenttextures[gl_state.currenttmu] = texnum; + gl.glBindTexture(GL_TEXTURE_2D, texnum); + } + + void GL_MBind(int target /* GLenum */ + , int texnum) { + GL_SelectTexture(target); + if (target == GL_TEXTURE0) { + if (gl_state.currenttextures[0] == texnum) + return; + } else { + if (gl_state.currenttextures[1] == texnum) + return; + } + GL_Bind(texnum); + } + + // glmode_t + static class glmode_t { + String name; + + int minimize, maximize; + + glmode_t(String name, int minimize, int maximze) { + this.name = name; + this.minimize = minimize; + this.maximize = maximze; + } + } + + static final glmode_t modes[] = { + new glmode_t("GL_NEAREST", GL_NEAREST, GL_NEAREST), + new glmode_t("GL_LINEAR", GL_LINEAR, GL_LINEAR), + new glmode_t("GL_NEAREST_MIPMAP_NEAREST", + GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST), + new glmode_t("GL_LINEAR_MIPMAP_NEAREST", + GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR), + new glmode_t("GL_NEAREST_MIPMAP_LINEAR", + GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST), + new glmode_t("GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, + GL_LINEAR) }; + + static final int NUM_GL_MODES = modes.length; + + // gltmode_t + static class gltmode_t { + String name; + + int mode; + + gltmode_t(String name, int mode) { + this.name = name; + this.mode = mode; + } + } + + static final gltmode_t[] gl_alpha_modes = { new gltmode_t("default", 4), + new gltmode_t("GL_RGBA", GL_RGBA), + new gltmode_t("GL_RGBA8", GL_RGBA8), + new gltmode_t("GL_RGB5_A1", GL_RGB5_A1), + new gltmode_t("GL_RGBA4", GL_RGBA4), + new gltmode_t("GL_RGBA2", GL_RGBA2), }; + + static final int NUM_GL_ALPHA_MODES = gl_alpha_modes.length; + + static final gltmode_t[] gl_solid_modes = { new gltmode_t("default", 3), + new gltmode_t("GL_RGB", GL_RGB), + new gltmode_t("GL_RGB8", GL_RGB8), + new gltmode_t("GL_RGB5", GL_RGB5), + new gltmode_t("GL_RGB4", GL_RGB4), + new gltmode_t("GL_R3_G3_B2", GL_R3_G3_B2), + }; + + static final int NUM_GL_SOLID_MODES = gl_solid_modes.length; + + /* + * =============== GL_TextureMode =============== + */ + void GL_TextureMode(String string) { + + int i; + for (i = 0; i < NUM_GL_MODES; i++) { + if (modes[i].name.equalsIgnoreCase(string)) + break; + } + + if (i == NUM_GL_MODES) { + VID + .Printf(Defines.PRINT_ALL, "bad filter name: [" + string + + "]\n"); + return; + } + + gl_filter_min = modes[i].minimize; + gl_filter_max = modes[i].maximize; + + image_t glt; + // change all the existing mipmap texture objects + for (i = 0; i < numgltextures; i++) { + glt = gltextures[i]; + + if (glt.type != it_pic && glt.type != it_sky) { + GL_Bind(glt.texnum); + gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + gl_filter_min); + gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, + gl_filter_max); + } + } + } + + /* + * =============== GL_TextureAlphaMode =============== + */ + void GL_TextureAlphaMode(String string) { + + int i; + for (i = 0; i < NUM_GL_ALPHA_MODES; i++) { + if (gl_alpha_modes[i].name.equalsIgnoreCase(string)) + break; + } + + if (i == NUM_GL_ALPHA_MODES) { + VID.Printf(Defines.PRINT_ALL, "bad alpha texture mode name: [" + + string + "]\n"); + return; + } + + gl_tex_alpha_format = gl_alpha_modes[i].mode; + } + + /* + * =============== GL_TextureSolidMode =============== + */ + void GL_TextureSolidMode(String string) { + int i; + for (i = 0; i < NUM_GL_SOLID_MODES; i++) { + if (gl_solid_modes[i].name.equalsIgnoreCase(string)) + break; + } + + if (i == NUM_GL_SOLID_MODES) { + VID.Printf(Defines.PRINT_ALL, "bad solid texture mode name: [" + + string + "]\n"); + return; + } + + gl_tex_solid_format = gl_solid_modes[i].mode; + } + + /* + * =============== GL_ImageList_f =============== + */ + void GL_ImageList_f() { + + image_t image; + int texels; + final String[] palstrings = { "RGB", "PAL" }; + + VID.Printf(Defines.PRINT_ALL, "------------------\n"); + texels = 0; + + for (int i = 0; i < numgltextures; i++) { + image = gltextures[i]; + if (image.texnum <= 0) + continue; + + texels += image.upload_width * image.upload_height; + switch (image.type) { + case it_skin: + VID.Printf(Defines.PRINT_ALL, "M"); + break; + case it_sprite: + VID.Printf(Defines.PRINT_ALL, "S"); + break; + case it_wall: + VID.Printf(Defines.PRINT_ALL, "W"); + break; + case it_pic: + VID.Printf(Defines.PRINT_ALL, "P"); + break; + default: + VID.Printf(Defines.PRINT_ALL, " "); + break; + } + + VID.Printf(Defines.PRINT_ALL, " %3i %3i %s: %s\n", new Vargs(4) + .add(image.upload_width).add(image.upload_height).add( + palstrings[(image.paletted) ? 1 : 0]).add( + image.name)); + } + VID.Printf(Defines.PRINT_ALL, + "Total texel count (not counting mipmaps): " + texels + '\n'); + } + + /* + * ============================================================================= + * + * scrap allocation + * + * Allocate all the little status bar objects into a single texture to + * crutch up inefficient hardware / drivers + * + * ============================================================================= + */ + + static final int MAX_SCRAPS = 1; + + static final int BLOCK_WIDTH = 256; + + static final int BLOCK_HEIGHT = 256; + + int[][] scrap_allocated = new int[MAX_SCRAPS][BLOCK_WIDTH]; + + byte[][] scrap_texels = new byte[MAX_SCRAPS][BLOCK_WIDTH * BLOCK_HEIGHT]; + + boolean scrap_dirty; + + static class pos_t { + int x, y; + + pos_t(int x, int y) { + this.x = x; + this.y = y; + } + } + + // returns a texture number and the position inside it + int Scrap_AllocBlock(int w, int h, pos_t pos) { + int i, j; + int best, best2; + int texnum; + + for (texnum = 0; texnum < MAX_SCRAPS; texnum++) { + best = BLOCK_HEIGHT; + + for (i = 0; i < BLOCK_WIDTH - w; i++) { + best2 = 0; + + for (j = 0; j < w; j++) { + if (scrap_allocated[texnum][i + j] >= best) + break; + if (scrap_allocated[texnum][i + j] > best2) + best2 = scrap_allocated[texnum][i + j]; + } + if (j == w) { // this is a valid spot + pos.x = i; + pos.y = best = best2; + } + } + + if (best + h > BLOCK_HEIGHT) + continue; + + for (i = 0; i < w; i++) + scrap_allocated[texnum][pos.x + i] = best + h; + + return texnum; + } + + return -1; + // Sys_Error ("Scrap_AllocBlock: full"); + } + + int scrap_uploads = 0; + + void Scrap_Upload() { + scrap_uploads++; + GL_Bind(TEXNUM_SCRAPS); + GL_Upload8(scrap_texels[0], BLOCK_WIDTH, BLOCK_HEIGHT, false, false); + scrap_dirty = false; + } + + /* + * ================================================================= + * + * PCX LOADING + * + * ================================================================= + */ + + /* + * ============== LoadPCX ============== + */ + byte[] LoadPCX(String filename, byte[][] palette, Dimension dim) { + qfiles.pcx_t pcx; + + // + // load the file + // + byte[] raw = FS.LoadFile(filename); + + if (raw == null) { + VID.Printf(Defines.PRINT_DEVELOPER, "Bad pcx file " + filename + + '\n'); + return null; + } + + // + // parse the PCX file + // + pcx = new qfiles.pcx_t(raw); + + if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 + || pcx.bits_per_pixel != 8 || pcx.xmax >= 640 + || pcx.ymax >= 480) { + + VID.Printf(Defines.PRINT_ALL, "Bad pcx file " + filename + '\n'); + return null; + } + + int width = pcx.xmax - pcx.xmin + 1; + int height = pcx.ymax - pcx.ymin + 1; + + byte[] pix = new byte[width * height]; + + if (palette != null) { + palette[0] = new byte[768]; + System.arraycopy(raw, raw.length - 768, palette[0], 0, 768); + } + + if (dim != null) { + dim.width = width; + dim.height = height; + } + + // + // decode pcx + // + int count = 0; + byte dataByte = 0; + int runLength = 0; + int x, y; + + for (y = 0; y < height; y++) { + for (x = 0; x < width;) { + + dataByte = pcx.data.get(); + + if ((dataByte & 0xC0) == 0xC0) { + runLength = dataByte & 0x3F; + dataByte = pcx.data.get(); + // write runLength pixel + while (runLength-- > 0) { + pix[count++] = dataByte; + x++; + } + } else { + // write one pixel + pix[count++] = dataByte; + x++; + } + } + } + return pix; + } + + // /* + // ========================================================= + // + // TARGA LOADING + // + // ========================================================= + // */ + /* + * ============= LoadTGA ============= + */ + byte[] LoadTGA(String name, Dimension dim) { + int columns, rows, numPixels; + int pixbuf; // index into pic + int row, column; + byte[] raw; + ByteBuffer buf_p; + int length; + qfiles.tga_t targa_header; + byte[] pic = null; + + // + // load the file + // + raw = FS.LoadFile(name); + + if (raw == null) { + VID.Printf(Defines.PRINT_DEVELOPER, "Bad tga file " + name + '\n'); + return null; + } + + targa_header = new qfiles.tga_t(raw); + + if (targa_header.image_type != 2 && targa_header.image_type != 10) + Com.Error(Defines.ERR_DROP, + "LoadTGA: Only type 2 and 10 targa RGB images supported\n"); + + if (targa_header.colormap_type != 0 + || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24)) + Com + .Error(Defines.ERR_DROP, + "LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n"); + + columns = targa_header.width; + rows = targa_header.height; + numPixels = columns * rows; + + if (dim != null) { + dim.width = columns; + dim.height = rows; + } + + pic = new byte[numPixels * 4]; // targa_rgba; + + if (targa_header.id_length != 0) + targa_header.data.position(targa_header.id_length); // skip TARGA + // image comment + + buf_p = targa_header.data; + + byte red, green, blue, alphabyte; + red = green = blue = alphabyte = 0; + int packetHeader, packetSize, j; + + if (targa_header.image_type == 2) { // Uncompressed, RGB images + for (row = rows - 1; row >= 0; row--) { + + pixbuf = row * columns * 4; + + for (column = 0; column < columns; column++) { + switch (targa_header.pixel_size) { + case 24: + + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = (byte) 255; + break; + case 32: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = alphabyte; + break; + } + } + } + } else if (targa_header.image_type == 10) { // Runlength encoded RGB + // images + for (row = rows - 1; row >= 0; row--) { + + pixbuf = row * columns * 4; + try { + + for (column = 0; column < columns;) { + + packetHeader = buf_p.get() & 0xFF; + packetSize = 1 + (packetHeader & 0x7f); + + if ((packetHeader & 0x80) != 0) { // run-length packet + switch (targa_header.pixel_size) { + case 24: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = (byte) 255; + break; + case 32: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = buf_p.get(); + break; + } + + for (j = 0; j < packetSize; j++) { + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = alphabyte; + column++; + if (column == columns) { // run spans across + // rows + column = 0; + if (row > 0) + row--; + else + // goto label breakOut; + throw new longjmpException(); + + pixbuf = row * columns * 4; + } + } + } else { // non run-length packet + for (j = 0; j < packetSize; j++) { + switch (targa_header.pixel_size) { + case 24: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = (byte) 255; + break; + case 32: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = alphabyte; + break; + } + column++; + if (column == columns) { // pixel packet run + // spans across rows + column = 0; + if (row > 0) + row--; + else + // goto label breakOut; + throw new longjmpException(); + + pixbuf = row * columns * 4; + } + } + } + } + } catch (longjmpException e) { + // label breakOut: + } + } + } + return pic; + } + + /* + * ==================================================================== + * + * IMAGE FLOOD FILLING + * + * ==================================================================== + */ + + /* + * ================= Mod_FloodFillSkin + * + * Fill background pixels so mipmapping doesn't have haloes + * ================= + */ + + static class floodfill_t { + short x, y; + } + + // must be a power of 2 + static final int FLOODFILL_FIFO_SIZE = 0x1000; + + static final int FLOODFILL_FIFO_MASK = FLOODFILL_FIFO_SIZE - 1; + + // + // #define FLOODFILL_STEP( off, dx, dy ) \ + // { \ + // if (pos[off] == fillcolor) \ + // { \ + // pos[off] = 255; \ + // fifo[inpt].x = x + (dx), fifo[inpt].y = y + (dy); \ + // inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \ + // } \ + // else if (pos[off] != 255) fdc = pos[off]; \ + // } + + // void FLOODFILL_STEP( int off, int dx, int dy ) + // { + // if (pos[off] == fillcolor) + // { + // pos[off] = 255; + // fifo[inpt].x = x + dx; fifo[inpt].y = y + dy; + // inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + // } + // else if (pos[off] != 255) fdc = pos[off]; + // } + static floodfill_t[] fifo = new floodfill_t[FLOODFILL_FIFO_SIZE]; + static { + for (int j = 0; j < fifo.length; j++) { + fifo[j] = new floodfill_t(); + } + } + + // TODO check this: R_FloodFillSkin( byte[] skin, int skinwidth, int + // skinheight) + void R_FloodFillSkin(byte[] skin, int skinwidth, int skinheight) { + // byte fillcolor = *skin; // assume this is the pixel to fill + int fillcolor = skin[0] & 0xff; + int inpt = 0, outpt = 0; + int filledcolor = -1; + int i; + + if (filledcolor == -1) { + filledcolor = 0; + // attempt to find opaque black + for (i = 0; i < 256; ++i) + // TODO check this + if (d_8to24table[i] == 0xFF000000) { // alpha 1.0 + //if (d_8to24table[i] == (255 << 0)) // alpha 1.0 + filledcolor = i; + break; + } + } + + // can't fill to filled color or to transparent color (used as visited + // marker) + if ((fillcolor == filledcolor) || (fillcolor == 255)) { + return; + } + + fifo[inpt].x = 0; + fifo[inpt].y = 0; + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + + while (outpt != inpt) { + int x = fifo[outpt].x; + int y = fifo[outpt].y; + int fdc = filledcolor; + // byte *pos = &skin[x + skinwidth * y]; + int pos = x + skinwidth * y; + // + outpt = (outpt + 1) & FLOODFILL_FIFO_MASK; + + int off, dx, dy; + + if (x > 0) { + // FLOODFILL_STEP( -1, -1, 0 ); + off = -1; + dx = -1; + dy = 0; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + } + + if (x < skinwidth - 1) { + // FLOODFILL_STEP( 1, 1, 0 ); + off = 1; + dx = 1; + dy = 0; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + } + + if (y > 0) { + // FLOODFILL_STEP( -skinwidth, 0, -1 ); + off = -skinwidth; + dx = 0; + dy = -1; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + } + + if (y < skinheight - 1) { + // FLOODFILL_STEP( skinwidth, 0, 1 ); + off = skinwidth; + dx = 0; + dy = 1; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + + } + + skin[x + skinwidth * y] = (byte) fdc; + } + } + + // ======================================================= + + /* + * ================ GL_ResampleTexture ================ + */ + // cwei :-) + void GL_ResampleTexture(int[] in, int inwidth, int inheight, int[] out, + int outwidth, int outheight) { + // int i, j; + // unsigned *inrow, *inrow2; + // int frac, fracstep; + // int[] p1 = new int[1024]; + // int[] p2 = new int[1024]; + // + + // *** this source do the same *** + BufferedImage image = new BufferedImage(inwidth, inheight, + BufferedImage.TYPE_INT_ARGB); + + image.setRGB(0, 0, inwidth, inheight, in, 0, inwidth); + + AffineTransformOp op = new AffineTransformOp(AffineTransform + .getScaleInstance(outwidth * 1.0 / inwidth, outheight * 1.0 + / inheight), AffineTransformOp.TYPE_NEAREST_NEIGHBOR); + BufferedImage tmp = op.filter(image, null); + + tmp.getRGB(0, 0, outwidth, outheight, out, 0, outwidth); + + // *** end *** + + // byte *pix1, *pix2, *pix3, *pix4; + // + // fracstep = inwidth*0x10000/outwidth; + // + // frac = fracstep>>2; + // for (i=0 ; i<outwidth ; i++) + // { + // p1[i] = 4*(frac>>16); + // frac += fracstep; + // } + // frac = 3*(fracstep>>2); + // for (i=0 ; i<outwidth ; i++) + // { + // p2[i] = 4*(frac>>16); + // frac += fracstep; + // } + // + // for (i=0 ; i<outheight ; i++, out += outwidth) + // { + // inrow = in + inwidth*(int)((i+0.25)*inheight/outheight); + // inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight); + // frac = fracstep >> 1; + // for (j=0 ; j<outwidth ; j++) + // { + // pix1 = (byte *)inrow + p1[j]; + // pix2 = (byte *)inrow + p2[j]; + // pix3 = (byte *)inrow2 + p1[j]; + // pix4 = (byte *)inrow2 + p2[j]; + // ((byte *)(out+j))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2; + // ((byte *)(out+j))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2; + // ((byte *)(out+j))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2; + // ((byte *)(out+j))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2; + // } + // } + } + + /* + * ================ GL_LightScaleTexture + * + * Scale up the pixel values in a texture to increase the lighting range + * ================ + */ + void GL_LightScaleTexture(int[] in, int inwidth, int inheight, + boolean only_gamma) { + if (only_gamma) { + int i, c; + int r, g, b, color; + + c = inwidth * inheight; + for (i = 0; i < c; i++) { + color = in[i]; + r = (color >> 0) & 0xFF; + g = (color >> 8) & 0xFF; + b = (color >> 16) & 0xFF; + + r = gammatable[r] & 0xFF; + g = gammatable[g] & 0xFF; + b = gammatable[b] & 0xFF; + + in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000); + } + } else { + int i, c; + int r, g, b, color; + + c = inwidth * inheight; + for (i = 0; i < c; i++) { + color = in[i]; + r = (color >> 0) & 0xFF; + g = (color >> 8) & 0xFF; + b = (color >> 16) & 0xFF; + + r = gammatable[intensitytable[r] & 0xFF] & 0xFF; + g = gammatable[intensitytable[g] & 0xFF] & 0xFF; + b = gammatable[intensitytable[b] & 0xFF] & 0xFF; + + in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000); + } + + } + } + + /* + * ================ GL_MipMap + * + * Operates in place, quartering the size of the texture ================ + */ + void GL_MipMap(int[] in, int width, int height) { + int i, j; + int[] out; + + out = in; + + int inIndex = 0; + int outIndex = 0; + + int r, g, b, a; + int p1, p2, p3, p4; + + for (i = 0; i < height; i += 2, inIndex += width) { + for (j = 0; j < width; j += 2, outIndex += 1, inIndex += 2) { + + p1 = in[inIndex + 0]; + p2 = in[inIndex + 1]; + p3 = in[inIndex + width + 0]; + p4 = in[inIndex + width + 1]; + + r = (((p1 >> 0) & 0xFF) + ((p2 >> 0) & 0xFF) + + ((p3 >> 0) & 0xFF) + ((p4 >> 0) & 0xFF)) >> 2; + g = (((p1 >> 8) & 0xFF) + ((p2 >> 8) & 0xFF) + + ((p3 >> 8) & 0xFF) + ((p4 >> 8) & 0xFF)) >> 2; + b = (((p1 >> 16) & 0xFF) + ((p2 >> 16) & 0xFF) + + ((p3 >> 16) & 0xFF) + ((p4 >> 16) & 0xFF)) >> 2; + a = (((p1 >> 24) & 0xFF) + ((p2 >> 24) & 0xFF) + + ((p3 >> 24) & 0xFF) + ((p4 >> 24) & 0xFF)) >> 2; + + out[outIndex] = (r << 0) | (g << 8) | (b << 16) | (a << 24); + } + } + } + + /* + * =============== GL_Upload32 + * + * Returns has_alpha =============== + */ + void GL_BuildPalettedTexture(ByteBuffer paletted_texture, int[] scaled, + int scaled_width, int scaled_height) { + + int r, g, b, c; + int size = scaled_width * scaled_height; + + for (int i = 0; i < size; i++) { + + r = (scaled[i] >> 3) & 31; + g = (scaled[i] >> 10) & 63; + b = (scaled[i] >> 19) & 31; + + c = r | (g << 5) | (b << 11); + + paletted_texture.put(i, gl_state.d_16to8table[c]); + } + } + + int upload_width, upload_height; + + boolean uploaded_paletted; + + /* + * =============== GL_Upload32 + * + * Returns has_alpha =============== + */ + int[] scaled = new int[256 * 256]; + + ByteBuffer paletted_texture = Lib.newByteBuffer(256*256); + + IntBuffer tex = Lib.newIntBuffer(512 * 256, ByteOrder.LITTLE_ENDIAN); + + boolean GL_Upload32(int[] data, int width, int height, boolean mipmap) { + int samples; + int scaled_width, scaled_height; + int i, c; + int comp; + + Arrays.fill(scaled, 0); + paletted_texture.clear(); + for (int j=0; j<256*256; j++) paletted_texture.put(j,(byte)0); + + uploaded_paletted = false; + + for (scaled_width = 1; scaled_width < width; scaled_width <<= 1) + ; + if (gl_round_down.value > 0.0f && scaled_width > width && mipmap) + scaled_width >>= 1; + for (scaled_height = 1; scaled_height < height; scaled_height <<= 1) + ; + if (gl_round_down.value > 0.0f && scaled_height > height && mipmap) + scaled_height >>= 1; + + // let people sample down the world textures for speed + if (mipmap) { + scaled_width >>= (int) gl_picmip.value; + scaled_height >>= (int) gl_picmip.value; + } + + // don't ever bother with >256 textures + if (scaled_width > 256) + scaled_width = 256; + if (scaled_height > 256) + scaled_height = 256; + + if (scaled_width < 1) + scaled_width = 1; + if (scaled_height < 1) + scaled_height = 1; + + upload_width = scaled_width; + upload_height = scaled_height; + + if (scaled_width * scaled_height > 256 * 256) + Com.Error(Defines.ERR_DROP, "GL_Upload32: too big"); + + // scan the texture for any non-255 alpha + c = width * height; + samples = gl_solid_format; + + for (i = 0; i < c; i++) { + if ((data[i] & 0xff000000) != 0xff000000) { + samples = gl_alpha_format; + break; + } + } + + if (samples == gl_solid_format) + comp = gl_tex_solid_format; + else if (samples == gl_alpha_format) + comp = gl_tex_alpha_format; + else { + VID.Printf(Defines.PRINT_ALL, + "Unknown number of texture components " + samples + '\n'); + comp = samples; + } + + // simulates a goto + try { + if (scaled_width == width && scaled_height == height) { + if (!mipmap) { + if (qglColorTableEXT + && gl_ext_palettedtexture.value != 0.0f + && samples == gl_solid_format) { + uploaded_paletted = true; + GL_BuildPalettedTexture(paletted_texture, data, + scaled_width, scaled_height); + gl.glTexImage2D(GL_TEXTURE_2D, 0, + GL_COLOR_INDEX8_EXT, scaled_width, + scaled_height, 0, GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, paletted_texture); + } else { + tex.clear(); + tex.put(data, 0, scaled_width * scaled_height).flip(); + gl.glTexImage2D(GL_TEXTURE_2D, 0, comp, + scaled_width, scaled_height, 0, GL_RGBA, + GL_UNSIGNED_BYTE, tex); + } + //goto done; + throw new longjmpException(); + } + //memcpy (scaled, data, width*height*4); were bytes + System.arraycopy(data, 0, scaled, 0, width * height); + + } else + GL_ResampleTexture(data, width, height, scaled, scaled_width, + scaled_height); + + GL_LightScaleTexture(scaled, scaled_width, scaled_height, !mipmap); + + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f + && (samples == gl_solid_format)) { + uploaded_paletted = true; + GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, + scaled_height); + gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, + scaled_width, scaled_height, 0, GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, paletted_texture); + } else { + tex.clear(); + tex.put(scaled, 0, scaled_width * scaled_height).flip(); + gl.glTexImage2D(GL_TEXTURE_2D, 0, comp, scaled_width, + scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex); + } + + if (mipmap) { + int miplevel; + miplevel = 0; + while (scaled_width > 1 || scaled_height > 1) { + GL_MipMap(scaled, scaled_width, scaled_height); + scaled_width >>= 1; + scaled_height >>= 1; + if (scaled_width < 1) + scaled_width = 1; + if (scaled_height < 1) + scaled_height = 1; + + miplevel++; + if (qglColorTableEXT + && gl_ext_palettedtexture.value != 0.0f + && samples == gl_solid_format) { + uploaded_paletted = true; + GL_BuildPalettedTexture(paletted_texture, scaled, + scaled_width, scaled_height); + gl.glTexImage2D(GL_TEXTURE_2D, miplevel, + GL_COLOR_INDEX8_EXT, scaled_width, + scaled_height, 0, GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, paletted_texture); + } else { + tex.clear(); + tex.put(scaled, 0, scaled_width * scaled_height).flip(); + gl.glTexImage2D(GL_TEXTURE_2D, miplevel, comp, + scaled_width, scaled_height, 0, GL_RGBA, + GL_UNSIGNED_BYTE, tex); + } + } + } + // label done: + } catch (longjmpException e) { + ; // replaces label done + } + + if (mipmap) { + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + gl_filter_min); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, + gl_filter_max); + } else { + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + gl_filter_max); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, + gl_filter_max); + } + + return (samples == gl_alpha_format); + } + + /* + * =============== GL_Upload8 + * + * Returns has_alpha =============== + */ + + int[] trans = new int[512 * 256]; + + boolean GL_Upload8(byte[] data, int width, int height, boolean mipmap, + boolean is_sky) { + + Arrays.fill(trans, 0); + + int s = width * height; + + if (s > trans.length) + Com.Error(Defines.ERR_DROP, "GL_Upload8: too large"); + + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && is_sky) { + gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, width, + height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, ByteBuffer.wrap(data)); + + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, + gl_filter_max); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, + gl_filter_max); + + // TODO check this + return false; + } else { + int p; + int rgb; + for (int i = 0; i < s; i++) { + p = data[i] & 0xff; + trans[i] = d_8to24table[p]; + + if (p == 255) { // transparent, so scan around for another color + // to avoid alpha fringes + // FIXME: do a full flood fill so mips work... + if (i > width && (data[i - width] & 0xff) != 255) + p = data[i - width] & 0xff; + else if (i < s - width && (data[i + width] & 0xff) != 255) + p = data[i + width] & 0xff; + else if (i > 0 && (data[i - 1] & 0xff) != 255) + p = data[i - 1] & 0xff; + else if (i < s - 1 && (data[i + 1] & 0xff) != 255) + p = data[i + 1] & 0xff; + else + p = 0; + // copy rgb components + + // ((byte *)&trans[i])[0] = ((byte *)&d_8to24table[p])[0]; + // ((byte *)&trans[i])[1] = ((byte *)&d_8to24table[p])[1]; + // ((byte *)&trans[i])[2] = ((byte *)&d_8to24table[p])[2]; + + trans[i] = d_8to24table[p] & 0x00FFFFFF; // only rgb + } + } + + return GL_Upload32(trans, width, height, mipmap); + } + } + + /* + * ================ GL_LoadPic + * + * This is also used as an entry point for the generated r_notexture + * ================ + */ + image_t GL_LoadPic(String name, byte[] pic, int width, int height, + int type, int bits) { + image_t image; + int i; + + // find a free image_t + for (i = 0; i < numgltextures; i++) { + image = gltextures[i]; + if (image.texnum == 0) + break; + } + + if (i == numgltextures) { + if (numgltextures == MAX_GLTEXTURES) + Com.Error(Defines.ERR_DROP, "MAX_GLTEXTURES"); + + numgltextures++; + } + image = gltextures[i]; + + if (name.length() > Defines.MAX_QPATH) + Com.Error(Defines.ERR_DROP, "Draw_LoadPic: \"" + name + + "\" is too long"); + + image.name = name; + image.registration_sequence = registration_sequence; + + image.width = width; + image.height = height; + image.type = type; + + if (type == it_skin && bits == 8) + R_FloodFillSkin(pic, width, height); + + // load little pics into the scrap + if (image.type == it_pic && bits == 8 && image.width < 64 + && image.height < 64) { + pos_t pos = new pos_t(0, 0); + int j, k; + + int texnum = Scrap_AllocBlock(image.width, image.height, pos); + + if (texnum == -1) { + // replace goto nonscrap + + image.scrap = false; + + image.texnum = TEXNUM_IMAGES + image.getId(); // image pos in + // array + GL_Bind(image.texnum); + + if (bits == 8) { + image.has_alpha = GL_Upload8(pic, width, height, + (image.type != it_pic && image.type != it_sky), + image.type == it_sky); + } else { + int[] tmp = new int[pic.length / 4]; + + for (i = 0; i < tmp.length; i++) { + tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & + // 0x000000FF; + tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & + // 0x0000FF00; + tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & + // 0x00FF0000; + tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & + // 0xFF000000; + } + + image.has_alpha = GL_Upload32(tmp, width, height, + (image.type != it_pic && image.type != it_sky)); + } + + image.upload_width = upload_width; // after power of 2 and + // scales + image.upload_height = upload_height; + image.paletted = uploaded_paletted; + image.sl = 0; + image.sh = 1; + image.tl = 0; + image.th = 1; + + return image; + } + + scrap_dirty = true; + + // copy the texels into the scrap block + k = 0; + for (i = 0; i < image.height; i++) + for (j = 0; j < image.width; j++, k++) + scrap_texels[texnum][(pos.y + i) * BLOCK_WIDTH + pos.x + j] = pic[k]; + + image.texnum = TEXNUM_SCRAPS + texnum; + image.scrap = true; + image.has_alpha = true; + image.sl = (pos.x + 0.01f) / (float) BLOCK_WIDTH; + image.sh = (pos.x + image.width - 0.01f) / (float) BLOCK_WIDTH; + image.tl = (pos.y + 0.01f) / (float) BLOCK_WIDTH; + image.th = (pos.y + image.height - 0.01f) / (float) BLOCK_WIDTH; + + } else { + // this was label nonscrap + + image.scrap = false; + + image.texnum = TEXNUM_IMAGES + image.getId(); //image pos in array + GL_Bind(image.texnum); + + if (bits == 8) { + image.has_alpha = GL_Upload8(pic, width, height, + (image.type != it_pic && image.type != it_sky), + image.type == it_sky); + } else { + int[] tmp = new int[pic.length / 4]; + + for (i = 0; i < tmp.length; i++) { + tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF; + tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00; + tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000; + tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000; + } + + image.has_alpha = GL_Upload32(tmp, width, height, + (image.type != it_pic && image.type != it_sky)); + } + image.upload_width = upload_width; // after power of 2 and scales + image.upload_height = upload_height; + image.paletted = uploaded_paletted; + image.sl = 0; + image.sh = 1; + image.tl = 0; + image.th = 1; + } + return image; + } + + /* + * ================ GL_LoadWal ================ + */ + image_t GL_LoadWal(String name) { + + image_t image = null; + + byte[] raw = FS.LoadFile(name); + if (raw == null) { + VID.Printf(Defines.PRINT_ALL, "GL_FindImage: can't load " + name + + '\n'); + return r_notexture; + } + + qfiles.miptex_t mt = new qfiles.miptex_t(raw); + + byte[] pix = new byte[mt.width * mt.height]; + System.arraycopy(raw, mt.offsets[0], pix, 0, pix.length); + + image = GL_LoadPic(name, pix, mt.width, mt.height, it_wall, 8); + + return image; + } + + /* + * =============== GL_FindImage + * + * Finds or loads the given image =============== + */ + image_t GL_FindImage(String name, int type) { + image_t image = null; + + // TODO loest das grossschreibungs problem + name = name.toLowerCase(); + // bughack for bad strings (fuck \0) + int index = name.indexOf('\0'); + if (index != -1) + name = name.substring(0, index); + + if (name == null || name.length() < 5) + return null; // Com.Error (ERR_DROP, "GL_FindImage: NULL name"); + // Com.Error (ERR_DROP, "GL_FindImage: bad name: %s", name); + + // look for it + for (int i = 0; i < numgltextures; i++) { + image = gltextures[i]; + if (name.equals(image.name)) { + image.registration_sequence = registration_sequence; + return image; + } + } + + // + // load the pic from disk + // + byte[] pic = null; + Dimension dim = new Dimension(); + + if (name.endsWith(".pcx")) { + + pic = LoadPCX(name, null, dim); + if (pic == null) + return null; + image = GL_LoadPic(name, pic, dim.width, dim.height, type, 8); + + } else if (name.endsWith(".wal")) { + + image = GL_LoadWal(name); + + } else if (name.endsWith(".tga")) { + + pic = LoadTGA(name, dim); + + if (pic == null) + return null; + + image = GL_LoadPic(name, pic, dim.width, dim.height, type, 32); + + } else + return null; + + return image; + } + + /* + * =============== R_RegisterSkin =============== + */ + public image_t R_RegisterSkin(String name) { + return GL_FindImage(name, it_skin); + } + + private IntBuffer texnum = Lib.newIntBuffer(1); + + /* + * ================ GL_FreeUnusedImages + * + * Any image that was not touched on this registration sequence will be + * freed. ================ + */ + void GL_FreeUnusedImages() { + + // never free r_notexture or particle texture + r_notexture.registration_sequence = registration_sequence; + r_particletexture.registration_sequence = registration_sequence; + + image_t image = null; + + for (int i = 0; i < numgltextures; i++) { + image = gltextures[i]; + // used this sequence + if (image.registration_sequence == registration_sequence) + continue; + // free image_t slot + if (image.registration_sequence == 0) + continue; + // don't free pics + if (image.type == it_pic) + continue; + + // free it + texnum.put(0, image.texnum); + gl.glDeleteTextures(texnum); + image.clear(); + } + } + + /* + * =============== Draw_GetPalette =============== + */ + protected void Draw_GetPalette() { + int r, g, b; + Dimension dim; + byte[] pic; + byte[][] palette = new byte[1][]; //new byte[768]; + + // get the palette + + pic = LoadPCX("pics/colormap.pcx", palette, dim = new Dimension()); + + if (palette[0] == null || palette[0].length != 768) + Com.Error(Defines.ERR_FATAL, "Couldn't load pics/colormap.pcx"); + + byte[] pal = palette[0]; + + int j = 0; + for (int i = 0; i < 256; i++) { + r = pal[j++] & 0xFF; + g = pal[j++] & 0xFF; + b = pal[j++] & 0xFF; + + d_8to24table[i] = (255 << 24) | (b << 16) | (g << 8) | (r << 0); + } + + d_8to24table[255] &= 0x00FFFFFF; // 255 is transparent + + particle_t.setColorPalette(d_8to24table); + } + + /* + * =============== GL_InitImages =============== + */ + void GL_InitImages() { + int i, j; + float g = vid_gamma.value; + + registration_sequence = 1; + + // init intensity conversions + intensity = Cvar.Get("intensity", "2", 0); + + if (intensity.value <= 1) + Cvar.Set("intensity", "1"); + + gl_state.inverse_intensity = 1 / intensity.value; + + Draw_GetPalette(); + + if (qglColorTableEXT) { + gl_state.d_16to8table = FS.LoadFile("pics/16to8.dat"); + if (gl_state.d_16to8table == null) + Com.Error(Defines.ERR_FATAL, "Couldn't load pics/16to8.pcx"); + } + + if ((gl_config.renderer & (GL_RENDERER_VOODOO | GL_RENDERER_VOODOO2)) != 0) { + g = 1.0F; + } + + for (i = 0; i < 256; i++) { + + if (g == 1.0f) { + gammatable[i] = (byte) i; + } else { + + int inf = (int) (255.0f * Math.pow((i + 0.5) / 255.5, g) + 0.5); + if (inf < 0) + inf = 0; + if (inf > 255) + inf = 255; + gammatable[i] = (byte) inf; + } + } + + for (i = 0; i < 256; i++) { + j = (int) (i * intensity.value); + if (j > 255) + j = 255; + intensitytable[i] = (byte) j; + } + } + + /* + * =============== GL_ShutdownImages =============== + */ + void GL_ShutdownImages() { + image_t image; + + for (int i = 0; i < numgltextures; i++) { + image = gltextures[i]; + + if (image.registration_sequence == 0) + continue; // free image_t slot + // free it + texnum.put(0, image.texnum); + gl.glDeleteTextures(texnum); + image.clear(); + } + } + +}
\ No newline at end of file diff --git a/src/jake2/render/basic/Light.java b/src/jake2/render/basic/Light.java new file mode 100644 index 0000000..e3af95f --- /dev/null +++ b/src/jake2/render/basic/Light.java @@ -0,0 +1,725 @@ +/* + * Light.java + * Copyright (C) 2003 + * + * $Id: Light.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.Globals; +import jake2.client.dlight_t; +import jake2.client.lightstyle_t; +import jake2.game.cplane_t; +import jake2.qcommon.Com; +import jake2.qcommon.longjmpException; +import jake2.render.mnode_t; +import jake2.render.msurface_t; +import jake2.render.mtexinfo_t; +import jake2.util.Math3D; + +import java.nio.ByteBuffer; +import java.nio.IntBuffer; +import java.util.Arrays; + +/** + * Light + * + * @author cwei + */ +public abstract class Light extends Warp { + // r_light.c + + int r_dlightframecount; + + static final int DLIGHT_CUTOFF = 64; + + /* + * ============================================================================= + * + * DYNAMIC LIGHTS BLEND RENDERING + * + * ============================================================================= + */ + + void R_RenderDlight(dlight_t light) { + int i, j; + float a; + float[] v = { 0, 0, 0 }; + float rad; + + rad = light.intensity * 0.35f; + + Math3D.VectorSubtract(light.origin, r_origin, v); + + gl.glBegin(GL_TRIANGLE_FAN); + gl.glColor3f(light.color[0] * 0.2f, light.color[1] * 0.2f, + light.color[2] * 0.2f); + for (i = 0; i < 3; i++) + v[i] = light.origin[i] - vpn[i] * rad; + gl.glVertex3f(v[0], v[1], v[2]); + gl.glColor3f(0, 0, 0); + 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); + gl.glVertex3f(v[0], v[1], v[2]); + } + gl.glEnd(); + } + + /* + * ============= R_RenderDlights ============= + */ + void R_RenderDlights() { + int i; + dlight_t l; + + if (gl_flashblend.value == 0) + return; + + r_dlightframecount = r_framecount + 1; // because the count hasn't + // advanced yet for this frame + gl.glDepthMask(false); + gl.glDisable(GL_TEXTURE_2D); + gl.glShadeModel(GL_SMOOTH); + gl.glEnable(GL_BLEND); + gl.glBlendFunc(GL_ONE, GL_ONE); + + for (i = 0; i < r_newrefdef.num_dlights; i++) { + l = r_newrefdef.dlights[i]; + R_RenderDlight(l); + } + + gl.glColor3f(1, 1, 1); + gl.glDisable(GL_BLEND); + gl.glEnable(GL_TEXTURE_2D); + gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl.glDepthMask(true); + } + + /* + * ============================================================================= + * + * DYNAMIC LIGHTS + * + * ============================================================================= + */ + + /* + * ============= R_MarkLights ============= + */ + void R_MarkLights(dlight_t light, int bit, mnode_t node) { + cplane_t splitplane; + float dist; + msurface_t surf; + int i; + int sidebit; + + if (node.contents != -1) + return; + + splitplane = node.plane; + dist = Math3D.DotProduct(light.origin, splitplane.normal) + - splitplane.dist; + + if (dist > light.intensity - DLIGHT_CUTOFF) { + R_MarkLights(light, bit, node.children[0]); + return; + } + if (dist < -light.intensity + DLIGHT_CUTOFF) { + R_MarkLights(light, bit, node.children[1]); + return; + } + + // mark the polygons + for (i = 0; i < node.numsurfaces; i++) { + + surf = r_worldmodel.surfaces[node.firstsurface + i]; + + /* + * cwei bugfix for dlight behind the walls + */ + dist = Math3D.DotProduct(light.origin, surf.plane.normal) + - surf.plane.dist; + sidebit = (dist >= 0) ? 0 : Defines.SURF_PLANEBACK; + if ((surf.flags & Defines.SURF_PLANEBACK) != sidebit) + continue; + /* + * cwei bugfix end + */ + + if (surf.dlightframe != r_dlightframecount) { + surf.dlightbits = 0; + surf.dlightframe = r_dlightframecount; + } + surf.dlightbits |= bit; + } + + R_MarkLights(light, bit, node.children[0]); + R_MarkLights(light, bit, node.children[1]); + } + + /* + * ============= R_PushDlights ============= + */ + void R_PushDlights() { + int i; + dlight_t l; + + if (gl_flashblend.value != 0) + return; + + r_dlightframecount = r_framecount + 1; // because the count hasn't + // advanced yet for this frame + for (i = 0; i < r_newrefdef.num_dlights; i++) { + l = r_newrefdef.dlights[i]; + R_MarkLights(l, 1 << i, r_worldmodel.nodes[0]); + } + } + + /* + * ============================================================================= + * + * LIGHT SAMPLING + * + * ============================================================================= + */ + + float[] pointcolor = { 0, 0, 0 }; // vec3_t + + cplane_t lightplane; // used as shadow plane + + float[] lightspot = { 0, 0, 0 }; // vec3_t + + int RecursiveLightPoint(mnode_t node, float[] start, float[] end) { + if (node.contents != -1) + return -1; // didn't hit anything + + msurface_t surf; + int s, t, ds, dt; + int i; + mtexinfo_t tex; + ByteBuffer lightmap; + int maps; + float[] mid = { 0, 0, 0 }; + + // calculate mid point + + // FIXME: optimize for axial + cplane_t plane = node.plane; + float front = Math3D.DotProduct(start, plane.normal) - plane.dist; + float back = Math3D.DotProduct(end, plane.normal) - plane.dist; + boolean side = (front < 0); + int sideIndex = (side) ? 1 : 0; + + if ((back < 0) == side) + return RecursiveLightPoint(node.children[sideIndex], start, end); + + float frac = front / (front - back); + mid[0] = start[0] + (end[0] - start[0]) * frac; + mid[1] = start[1] + (end[1] - start[1]) * frac; + mid[2] = start[2] + (end[2] - start[2]) * frac; + + // go down front side + int r = RecursiveLightPoint(node.children[sideIndex], start, mid); + if (r >= 0) + return r; // hit something + + if ((back < 0) == side) + return -1; // didn't hit anuthing + + // check for impact on this node + Math3D.VectorCopy(mid, lightspot); + lightplane = plane; + + int surfIndex = node.firstsurface; + float[] scale = { 0, 0, 0 }; + for (i = 0; i < node.numsurfaces; i++, surfIndex++) { + surf = r_worldmodel.surfaces[surfIndex]; + + if ((surf.flags & (Defines.SURF_DRAWTURB | Defines.SURF_DRAWSKY)) != 0) + continue; // no lightmaps + + tex = surf.texinfo; + + s = (int) (Math3D.DotProduct(mid, tex.vecs[0]) + tex.vecs[0][3]); + t = (int) (Math3D.DotProduct(mid, tex.vecs[1]) + tex.vecs[1][3]); + + if (s < surf.texturemins[0] || t < surf.texturemins[1]) + continue; + + ds = s - surf.texturemins[0]; + dt = t - surf.texturemins[1]; + + if (ds > surf.extents[0] || dt > surf.extents[1]) + continue; + + if (surf.samples == null) + return 0; + + ds >>= 4; + dt >>= 4; + + lightmap = surf.samples; + int lightmapIndex = 0; + + Math3D.VectorCopy(Globals.vec3_origin, pointcolor); + if (lightmap != null) { + //float[] scale = {0, 0, 0}; + float[] rgb; + lightmapIndex += 3 * (dt * ((surf.extents[0] >> 4) + 1) + ds); + + for (maps = 0; maps < Defines.MAXLIGHTMAPS + && surf.styles[maps] != (byte) 255; maps++) { + rgb = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb; + scale[0] = gl_modulate.value * rgb[0]; + scale[1] = gl_modulate.value * rgb[1]; + scale[2] = gl_modulate.value * rgb[2]; + + pointcolor[0] += (lightmap.get(lightmapIndex + 0) & 0xFF) + * scale[0] * (1.0f / 255); + pointcolor[1] += (lightmap.get(lightmapIndex + 1) & 0xFF) + * scale[1] * (1.0f / 255); + pointcolor[2] += (lightmap.get(lightmapIndex + 2) & 0xFF) + * scale[2] * (1.0f / 255); + lightmapIndex += 3 * ((surf.extents[0] >> 4) + 1) + * ((surf.extents[1] >> 4) + 1); + } + } + return 1; + } + + // go down back side + return RecursiveLightPoint(node.children[1 - sideIndex], mid, end); + } + + /* + * =============== R_LightPoint =============== + */ + void R_LightPoint(float[] p, float[] color) { + assert (p.length == 3) : "vec3_t bug"; + assert (color.length == 3) : "rgb bug"; + + float[] end = { 0, 0, 0 }; + dlight_t dl; + float add; + + if (r_worldmodel.lightdata == null) { + color[0] = color[1] = color[2] = 1.0f; + return; + } + + end[0] = p[0]; + end[1] = p[1]; + end[2] = p[2] - 2048; + + float r = RecursiveLightPoint(r_worldmodel.nodes[0], p, end); + + if (r == -1) { + Math3D.VectorCopy(Globals.vec3_origin, color); + } else { + Math3D.VectorCopy(pointcolor, color); + } + + // + // add dynamic lights + // + for (int lnum = 0; lnum < r_newrefdef.num_dlights; lnum++) { + dl = r_newrefdef.dlights[lnum]; + + Math3D.VectorSubtract(currententity.origin, dl.origin, end); + add = dl.intensity - Math3D.VectorLength(end); + add *= (1.0f / 256); + if (add > 0) { + Math3D.VectorMA(color, add, dl.color, color); + } + } + + Math3D.VectorScale(color, gl_modulate.value, color); + } + + // =================================================================== + + float[] s_blocklights = new float[34 * 34 * 3]; + + /* + * =============== R_AddDynamicLights =============== + */ + void R_AddDynamicLights(msurface_t surf) { + int lnum; + int sd, td; + float fdist, frad, fminlight; + float[] impact = { 0, 0, 0 }; + float[] local = { 0, 0, 0 }; + int s, t; + int i; + int smax, tmax; + mtexinfo_t tex; + dlight_t dl; + float[] pfBL; + float fsacc, ftacc; + + smax = (surf.extents[0] >> 4) + 1; + tmax = (surf.extents[1] >> 4) + 1; + tex = surf.texinfo; + + for (lnum = 0; lnum < r_newrefdef.num_dlights; lnum++) { + if ((surf.dlightbits & (1 << lnum)) == 0) + continue; // not lit by this light + + dl = r_newrefdef.dlights[lnum]; + frad = dl.intensity; + fdist = Math3D.DotProduct(dl.origin, surf.plane.normal) + - surf.plane.dist; + frad -= Math.abs(fdist); + // rad is now the highest intensity on the plane + + fminlight = DLIGHT_CUTOFF; // FIXME: make configurable? + if (frad < fminlight) + continue; + fminlight = frad - fminlight; + + for (i = 0; i < 3; i++) { + impact[i] = dl.origin[i] - surf.plane.normal[i] * fdist; + } + + local[0] = Math3D.DotProduct(impact, tex.vecs[0]) + tex.vecs[0][3] + - surf.texturemins[0]; + local[1] = Math3D.DotProduct(impact, tex.vecs[1]) + tex.vecs[1][3] + - surf.texturemins[1]; + + pfBL = s_blocklights; + int pfBLindex = 0; + for (t = 0, ftacc = 0; t < tmax; t++, ftacc += 16) { + td = (int) (local[1] - ftacc); + if (td < 0) + td = -td; + + for (s = 0, fsacc = 0; s < smax; s++, fsacc += 16, pfBLindex += 3) { + sd = (int) (local[0] - fsacc); + + if (sd < 0) + sd = -sd; + + if (sd > td) + fdist = sd + (td >> 1); + else + fdist = td + (sd >> 1); + + if (fdist < fminlight) { + pfBL[pfBLindex + 0] += (frad - fdist) * dl.color[0]; + pfBL[pfBLindex + 1] += (frad - fdist) * dl.color[1]; + pfBL[pfBLindex + 2] += (frad - fdist) * dl.color[2]; + } + } + } + } + } + + /* + * * R_SetCacheState + */ + void R_SetCacheState(msurface_t surf) { + int maps; + + for (maps = 0; maps < Defines.MAXLIGHTMAPS + && surf.styles[maps] != (byte) 255; maps++) { + surf.cached_light[maps] = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].white; + } + } + + /* + * =============== R_BuildLightMap + * + * Combine and scale multiple lightmaps into the floating format in + * blocklights =============== + */ + void R_BuildLightMap(msurface_t surf, IntBuffer dest, int stride) { + int smax, tmax; + int r, g, b, a, max; + int i, j, size; + ByteBuffer lightmap; + float[] scale = { 0, 0, 0, 0 }; + int nummaps; + float[] bl; + lightstyle_t style; + int monolightmap; + + if ((surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 + | Defines.SURF_TRANS66 | Defines.SURF_WARP)) != 0) + Com.Error(Defines.ERR_DROP, + "R_BuildLightMap called for non-lit surface"); + + smax = (surf.extents[0] >> 4) + 1; + tmax = (surf.extents[1] >> 4) + 1; + size = smax * tmax; + if (size > ((s_blocklights.length * Defines.SIZE_OF_FLOAT) >> 4)) + Com.Error(Defines.ERR_DROP, "Bad s_blocklights size"); + + try { + // set to full bright if no light data + if (surf.samples == null) { + int maps; + + for (i = 0; i < size * 3; i++) + s_blocklights[i] = 255; + + for (maps = 0; maps < Defines.MAXLIGHTMAPS + && surf.styles[maps] != (byte) 255; maps++) { + style = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF]; + } + // goto store; + throw new longjmpException(); + } + + // count the # of maps + for (nummaps = 0; nummaps < Defines.MAXLIGHTMAPS + && surf.styles[nummaps] != (byte) 255; nummaps++) + ; + + lightmap = surf.samples; + int lightmapIndex = 0; + + // add all the lightmaps + if (nummaps == 1) { + int maps; + + for (maps = 0; maps < Defines.MAXLIGHTMAPS + && surf.styles[maps] != (byte) 255; maps++) { + bl = s_blocklights; + int blp = 0; + + for (i = 0; i < 3; i++) + scale[i] = gl_modulate.value + * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i]; + + if (scale[0] == 1.0F && scale[1] == 1.0F + && scale[2] == 1.0F) { + for (i = 0; i < size; i++) { + bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; + } + } else { + for (i = 0; i < size; i++) { + bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) + * scale[0]; + bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) + * scale[1]; + bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) + * scale[2]; + } + } + //lightmap += size*3; // skip to next lightmap + } + } else { + int maps; + + // memset( s_blocklights, 0, sizeof( s_blocklights[0] ) * size * + // 3 ); + + Arrays.fill(s_blocklights, 0, size * 3, 0.0f); + + for (maps = 0; maps < Defines.MAXLIGHTMAPS + && surf.styles[maps] != (byte) 255; maps++) { + bl = s_blocklights; + int blp = 0; + + for (i = 0; i < 3; i++) + scale[i] = gl_modulate.value + * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i]; + + if (scale[0] == 1.0F && scale[1] == 1.0F + && scale[2] == 1.0F) { + for (i = 0; i < size; i++) { + bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; + } + } else { + for (i = 0; i < size; i++) { + bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) + * scale[0]; + bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) + * scale[1]; + bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) + * scale[2]; + } + } + //lightmap += size*3; // skip to next lightmap + } + } + + // add all the dynamic lights + if (surf.dlightframe == r_framecount) + R_AddDynamicLights(surf); + + // label store: + } catch (longjmpException store) { + } + + // put into texture format + stride -= smax; + bl = s_blocklights; + int blp = 0; + + monolightmap = gl_monolightmap.string.charAt(0); + + int destp = 0; + + if (monolightmap == '0') { + for (i = 0; i < tmax; i++, destp += stride) { + for (j = 0; j < smax; j++) { + + r = (int) bl[blp++]; + g = (int) bl[blp++]; + b = (int) bl[blp++]; + + // catch negative lights + if (r < 0) + r = 0; + if (g < 0) + g = 0; + if (b < 0) + b = 0; + + /* + * * determine the brightest of the three color components + */ + if (r > g) + max = r; + else + max = g; + if (b > max) + max = b; + + /* + * * alpha is ONLY used for the mono lightmap case. For this + * reason * we set it to the brightest of the color + * components so that * things don't get too dim. + */ + a = max; + + /* + * * rescale all the color components if the intensity of + * the greatest * channel exceeds 1.0 + */ + if (max > 255) { + float t = 255.0F / max; + + r = (int) (r * t); + g = (int) (g * t); + b = (int) (b * t); + a = (int) (a * t); + } + r &= 0xFF; + g &= 0xFF; + b &= 0xFF; + a &= 0xFF; + dest.put(destp++, (a << 24) | (b << 16) | (g << 8) + | (r << 0)); + } + } + } else { + for (i = 0; i < tmax; i++, destp += stride) { + for (j = 0; j < smax; j++) { + + r = (int) bl[blp++]; + g = (int) bl[blp++]; + b = (int) bl[blp++]; + + // catch negative lights + if (r < 0) + r = 0; + if (g < 0) + g = 0; + if (b < 0) + b = 0; + + /* + * * determine the brightest of the three color components + */ + if (r > g) + max = r; + else + max = g; + if (b > max) + max = b; + + /* + * * alpha is ONLY used for the mono lightmap case. For this + * reason * we set it to the brightest of the color + * components so that * things don't get too dim. + */ + a = max; + + /* + * * rescale all the color components if the intensity of + * the greatest * channel exceeds 1.0 + */ + if (max > 255) { + float t = 255.0F / max; + + r = (int) (r * t); + g = (int) (g * t); + b = (int) (b * t); + a = (int) (a * t); + } + + /* + * * So if we are doing alpha lightmaps we need to set the + * R, G, and B * components to 0 and we need to set alpha to + * 1-alpha. + */ + switch (monolightmap) { + case 'L': + case 'I': + r = a; + g = b = 0; + break; + case 'C': + // try faking colored lighting + a = 255 - ((r + g + b) / 3); + r *= a / 255.0f; + g *= a / 255.0f; + b *= a / 255.0f; + break; + case 'A': + default: + r = g = b = 0; + a = 255 - a; + break; + } + r &= 0xFF; + g &= 0xFF; + b &= 0xFF; + a &= 0xFF; + dest.put(destp++, (a << 24) | (b << 16) | (g << 8) + | (r << 0)); + } + } + } + } + +}
\ No newline at end of file diff --git a/src/jake2/render/basic/Main.java b/src/jake2/render/basic/Main.java new file mode 100644 index 0000000..9dfdaff --- /dev/null +++ b/src/jake2/render/basic/Main.java @@ -0,0 +1,1586 @@ +/* + * Main.java + * Copyright (C) 2003 + * + * $Id: Main.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.Globals; +import jake2.client.*; +import jake2.game.*; +import jake2.qcommon.*; +import jake2.render.*; +import jake2.util.*; + +import java.awt.Dimension; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; + +/** + * Main + * + * @author cwei + */ +public abstract class Main extends Base { + + public static int[] d_8to24table = new int[256]; + + int c_visible_lightmaps; + int c_visible_textures; + + int registration_sequence; + + // this a hack for function pointer test + // default disabled + boolean qglColorTableEXT = false; + boolean qglSelectTextureSGIS = false; + boolean qglActiveTextureARB = false; + boolean qglPointParameterfEXT = false; + boolean qglLockArraysEXT = false; + boolean qglMTexCoord2fSGIS = false; + boolean qwglSwapIntervalEXT = false; + + // ================= + // abstract methods + // ================= + protected abstract void Draw_GetPalette(); + + abstract void GL_ImageList_f(); + abstract void GL_ScreenShot_f(); + abstract void GL_SetTexturePalette(int[] palette); + abstract void GL_Strings_f(); + + abstract void Mod_Modellist_f(); + abstract mleaf_t Mod_PointInLeaf(float[] point, model_t model); + + abstract void GL_SetDefaultState(); + + abstract void GL_InitImages(); + abstract void Mod_Init(); // Model.java + abstract void R_InitParticleTexture(); // MIsc.java + abstract void R_DrawAliasModel(entity_t e); // Mesh.java + abstract void R_DrawBrushModel(entity_t e); // Surf.java + abstract void Draw_InitLocal(); + abstract void R_LightPoint(float[] p, float[] color); + abstract void R_PushDlights(); + abstract void R_MarkLeaves(); + abstract void R_DrawWorld(); + abstract void R_RenderDlights(); + abstract void R_DrawAlphaSurfaces(); + + abstract void Mod_FreeAll(); + + abstract void GL_ShutdownImages(); + abstract void GL_Bind(int texnum); + abstract void GL_TexEnv(int mode); + abstract void GL_TextureMode(String string); + abstract void GL_TextureAlphaMode(String string); + abstract void GL_TextureSolidMode(String string); + abstract void GL_UpdateSwapInterval(); + + /* + ==================================================================== + + from gl_rmain.c + + ==================================================================== + */ + + model_t r_worldmodel; + + float gldepthmin, gldepthmax; + + glconfig_t gl_config = new glconfig_t(); + glstate_t gl_state = new glstate_t(); + + image_t r_notexture; // use for bad textures + image_t r_particletexture; // little dot for particles + + entity_t currententity; + model_t currentmodel; + + cplane_t frustum[] = { new cplane_t(), new cplane_t(), new cplane_t(), new cplane_t()}; + + int r_visframecount; // bumped when going to a new PVS + int r_framecount; // used for dlight push checking + + int c_brush_polys, c_alias_polys; + + float v_blend[] = { 0, 0, 0, 0 }; // final blending color + + // + // view origin + // + float[] vup = { 0, 0, 0 }; + float[] vpn = { 0, 0, 0 }; + float[] vright = { 0, 0, 0 }; + float[] r_origin = { 0, 0, 0 }; + + FloatBuffer r_world_matrix = Lib.newFloatBuffer(16); + float r_base_world_matrix[] = new float[16]; + + // + // screen size info + // + refdef_t r_newrefdef = new refdef_t(); + + int r_viewcluster, r_viewcluster2, r_oldviewcluster, r_oldviewcluster2; + + cvar_t r_norefresh; + cvar_t r_drawentities; + cvar_t r_drawworld; + cvar_t r_speeds; + cvar_t r_fullbright; + cvar_t r_novis; + cvar_t r_nocull; + cvar_t r_lerpmodels; + cvar_t r_lefthand; + + cvar_t r_lightlevel; + // FIXME: This is a HACK to get the client's light level + + cvar_t gl_nosubimage; + cvar_t gl_allow_software; + + cvar_t gl_vertex_arrays; + + cvar_t gl_particle_min_size; + cvar_t gl_particle_max_size; + cvar_t gl_particle_size; + cvar_t gl_particle_att_a; + cvar_t gl_particle_att_b; + cvar_t gl_particle_att_c; + + cvar_t gl_ext_swapinterval; + cvar_t gl_ext_palettedtexture; + cvar_t gl_ext_multitexture; + cvar_t gl_ext_pointparameters; + cvar_t gl_ext_compiled_vertex_array; + + cvar_t gl_log; + cvar_t gl_bitdepth; + cvar_t gl_drawbuffer; + cvar_t gl_driver; + cvar_t gl_lightmap; + cvar_t gl_shadows; + cvar_t gl_mode; + cvar_t gl_dynamic; + cvar_t gl_monolightmap; + cvar_t gl_modulate; + cvar_t gl_nobind; + cvar_t gl_round_down; + cvar_t gl_picmip; + cvar_t gl_skymip; + cvar_t gl_showtris; + cvar_t gl_ztrick; + cvar_t gl_finish; + cvar_t gl_clear; + cvar_t gl_cull; + cvar_t gl_polyblend; + cvar_t gl_flashblend; + cvar_t gl_playermip; + cvar_t gl_saturatelighting; + cvar_t gl_swapinterval; + cvar_t gl_texturemode; + cvar_t gl_texturealphamode; + cvar_t gl_texturesolidmode; + cvar_t gl_lockpvs; + + cvar_t gl_3dlabs_broken; + + cvar_t vid_gamma; + cvar_t vid_ref; + + // ============================================================================ + // to port from gl_rmain.c, ... + // ============================================================================ + + /* + ================= + R_CullBox + + Returns true if the box is completely outside the frustom + ================= + */ + final boolean R_CullBox(float[] mins, float[] maxs) { + assert(mins.length == 3 && maxs.length == 3) : "vec3_t bug"; + + if (r_nocull.value != 0) + return false; + + for (int i = 0; i < 4; i++) { + if (Math3D.BoxOnPlaneSide(mins, maxs, frustum[i]) == 2) + return true; + } + return false; + } + + final void R_RotateForEntity(entity_t e) { + + gl.glTranslatef(e.origin[0], e.origin[1], e.origin[2]); + + gl.glRotatef(e.angles[1], 0, 0, 1); + gl.glRotatef(-e.angles[0], 0, 1, 0); + gl.glRotatef(-e.angles[2], 1, 0, 0); + } + + /* + ============================================================= + + SPRITE MODELS + + ============================================================= + */ + + /* + ================= + R_DrawSpriteModel + + ================= + */ + void R_DrawSpriteModel(entity_t e) { + float alpha = 1.0F; + float[] point = { 0, 0, 0 }; + + 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) + gl.glEnable(GL_BLEND); + + gl.glColor4f(1, 1, 1, alpha); + + GL_Bind(currentmodel.skins[e.frame].texnum); + + GL_TexEnv(GL_MODULATE); + + if (alpha == 1.0) + gl.glEnable(GL_ALPHA_TEST); + else + gl.glDisable(GL_ALPHA_TEST); + + gl.glBegin(GL_QUADS); + + gl.glTexCoord2f(0, 1); + Math3D.VectorMA(e.origin, -frame.origin_y, vup, point); + Math3D.VectorMA(point, -frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glTexCoord2f(0, 0); + Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point); + Math3D.VectorMA(point, -frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glTexCoord2f(1, 0); + Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point); + Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glTexCoord2f(1, 1); + Math3D.VectorMA(e.origin, -frame.origin_y, vup, point); + Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glEnd(); + + gl.glDisable(GL_ALPHA_TEST); + GL_TexEnv(GL_REPLACE); + + if (alpha != 1.0F) + gl.glDisable(GL_BLEND); + + gl.glColor4f(1, 1, 1, 1); + } + + // ================================================================================== + + /* + ============= + R_DrawNullModel + ============= + cwei :-) + */ + void R_DrawNullModel() { + float[] shadelight = { 0, 0, 0 }; + + if ((currententity.flags & Defines.RF_FULLBRIGHT) != 0) { + // cwei wollte blau: shadelight[0] = shadelight[1] = shadelight[2] = 1.0F; + shadelight[0] = shadelight[1] = shadelight[2] = 0.0F; + shadelight[2] = 0.8F; + } + else { + R_LightPoint(currententity.origin, shadelight); + } + + gl.glPushMatrix(); + R_RotateForEntity(currententity); + + gl.glDisable(GL_TEXTURE_2D); + gl.glColor3f(shadelight[0], shadelight[1], shadelight[2]); + +// // this replaces the TRIANGLE_FAN +// glut.glutWireCube(gl, 20); + + + gl.glBegin(GL_TRIANGLE_FAN); + gl.glVertex3f(0, 0, -16); + int i; + for (i=0 ; i<=4 ; i++) { + gl.glVertex3f((float)(16.0f * Math.cos(i * Math.PI / 2)), (float)(16.0f * Math.sin(i * Math.PI / 2)), 0.0f); + } + gl.glEnd(); + + gl.glBegin(GL_TRIANGLE_FAN); + gl.glVertex3f (0, 0, 16); + for (i=4 ; i>=0 ; i--) { + gl.glVertex3f((float)(16.0f * Math.cos(i * Math.PI / 2)), (float)(16.0f * Math.sin(i * Math.PI / 2)), 0.0f); + } + gl.glEnd(); + + gl.glColor3f(1, 1, 1); + gl.glPopMatrix(); + gl.glEnable(GL_TEXTURE_2D); + } + + /* + ============= + R_DrawEntitiesOnList + ============= + */ + void R_DrawEntitiesOnList() { + int i; + + if (r_drawentities.value == 0.0f) + return; + + // draw non-transparent first + for (i = 0; i < r_newrefdef.num_entities; i++) { + currententity = r_newrefdef.entities[i]; + if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) + continue; // solid + + if ((currententity.flags & Defines.RF_BEAM) != 0) { + R_DrawBeam(currententity); + } + else { + currentmodel = currententity.model; + if (currentmodel == null) { + R_DrawNullModel(); + continue; + } + switch (currentmodel.type) { + case mod_alias : + R_DrawAliasModel(currententity); + break; + case mod_brush : + R_DrawBrushModel(currententity); + break; + case mod_sprite : + R_DrawSpriteModel(currententity); + break; + default : + Com.Error(Defines.ERR_DROP, "Bad modeltype"); + break; + } + } + } + // draw transparent entities + // we could sort these if it ever becomes a problem... + gl.glDepthMask(false); // no z writes + for (i = 0; i < r_newrefdef.num_entities; i++) { + currententity = r_newrefdef.entities[i]; + if ((currententity.flags & Defines.RF_TRANSLUCENT) == 0) + continue; // solid + + if ((currententity.flags & Defines.RF_BEAM) != 0) { + R_DrawBeam(currententity); + } + else { + currentmodel = currententity.model; + + if (currentmodel == null) { + R_DrawNullModel(); + continue; + } + switch (currentmodel.type) { + case mod_alias : + R_DrawAliasModel(currententity); + break; + case mod_brush : + R_DrawBrushModel(currententity); + break; + case mod_sprite : + R_DrawSpriteModel(currententity); + break; + default : + Com.Error(Defines.ERR_DROP, "Bad modeltype"); + break; + } + } + } + gl.glDepthMask(true); // back to writing + } + + /* + ** GL_DrawParticles + ** + */ + void GL_DrawParticles(int num_particles) { + float[] up = { 0, 0, 0 }; + float[] right = { 0, 0, 0 }; + float scale; + int color; + + float origin_x, origin_y, origin_z; + + Math3D.VectorScale(vup, 1.5f, up); + Math3D.VectorScale(vright, 1.5f, right); + + GL_Bind(r_particletexture.texnum); + gl.glDepthMask(false); // no z buffering + gl.glEnable(GL_BLEND); + GL_TexEnv(GL_MODULATE); + + gl.glBegin(GL_TRIANGLES); + + FloatBuffer sourceVertices = particle_t.vertexArray; + IntBuffer sourceColors = particle_t.colorArray; + for (int j = 0, i = 0; i < num_particles; i++) { + origin_x = sourceVertices.get(j++); + origin_y = sourceVertices.get(j++); + origin_z = sourceVertices.get(j++); + + // hack a scale up to keep particles from disapearing + scale = + (origin_x - r_origin[0]) * vpn[0] + + (origin_y - r_origin[1]) * vpn[1] + + (origin_z - r_origin[2]) * vpn[2]; + + scale = (scale < 20) ? 1 : 1 + scale * 0.004f; + + color = sourceColors.get(i); + gl.glColor4ub( + (byte)((color >> 0) & 0xFF), + (byte)((color >> 8) & 0xFF), + (byte)((color >> 16) & 0xFF), + (byte)((color >> 24) & 0xFF) + ); + // first vertex + gl.glTexCoord2f(0.0625f, 0.0625f); + gl.glVertex3f(origin_x, origin_y, origin_z); + // second vertex + gl.glTexCoord2f(1.0625f, 0.0625f); + gl.glVertex3f(origin_x + up[0] * scale, origin_y + up[1] * scale, origin_z + up[2] * scale); + // third vertex + gl.glTexCoord2f(0.0625f, 1.0625f); + gl.glVertex3f(origin_x + right[0] * scale, origin_y + right[1] * scale, origin_z + right[2] * scale); + } + gl.glEnd(); + + gl.glDisable(GL_BLEND); + gl.glColor4f(1, 1, 1, 1); + gl.glDepthMask(true); // back to normal Z buffering + GL_TexEnv(GL_REPLACE); + } + + /* + =============== + R_DrawParticles + =============== + */ + void R_DrawParticles() { + + if (gl_ext_pointparameters.value != 0.0f && qglPointParameterfEXT) { + + gl.glEnableClientState(GL_VERTEX_ARRAY); + gl.glVertexPointer(3, 0, particle_t.vertexArray); + gl.glEnableClientState(GL_COLOR_ARRAY); + gl.glColorPointer(4, true, 0, particle_t.getColorAsByteBuffer()); + + gl.glDepthMask(false); + gl.glEnable(GL_BLEND); + gl.glDisable(GL_TEXTURE_2D); + gl.glPointSize(gl_particle_size.value); + + gl.glDrawArrays(GL_POINTS, 0, r_newrefdef.num_particles); + + gl.glDisableClientState(GL_COLOR_ARRAY); + gl.glDisableClientState(GL_VERTEX_ARRAY); + + gl.glDisable(GL_BLEND); + gl.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + gl.glDepthMask(true); + gl.glEnable(GL_TEXTURE_2D); + + } + else { + GL_DrawParticles(r_newrefdef.num_particles); + } + } + + /* + ============ + R_PolyBlend + ============ + */ + void R_PolyBlend() { + if (gl_polyblend.value == 0.0f) + return; + + if (v_blend[3] == 0.0f) + return; + + gl.glDisable(GL_ALPHA_TEST); + gl.glEnable(GL_BLEND); + gl.glDisable(GL_DEPTH_TEST); + gl.glDisable(GL_TEXTURE_2D); + + gl.glLoadIdentity(); + + // FIXME: get rid of these + gl.glRotatef(-90, 1, 0, 0); // put Z going up + gl.glRotatef(90, 0, 0, 1); // put Z going up + + gl.glColor4f(v_blend[0], v_blend[1], v_blend[2], v_blend[3]); + + gl.glBegin(GL_QUADS); + + gl.glVertex3f(10, 100, 100); + gl.glVertex3f(10, -100, 100); + gl.glVertex3f(10, -100, -100); + gl.glVertex3f(10, 100, -100); + gl.glEnd(); + + gl.glDisable(GL_BLEND); + gl.glEnable(GL_TEXTURE_2D); + gl.glEnable(GL_ALPHA_TEST); + + gl.glColor4f(1, 1, 1, 1); + } + + // ======================================================================= + + int SignbitsForPlane(cplane_t out) { + // for fast box on planeside test + int bits = 0; + for (int j = 0; j < 3; j++) { + if (out.normal[j] < 0) + bits |= (1 << j); + } + return bits; + } + + void R_SetFrustum() { + // rotate VPN right by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[0].normal, vup, vpn, - (90f - r_newrefdef.fov_x / 2f)); + // rotate VPN left by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[1].normal, vup, vpn, 90f - r_newrefdef.fov_x / 2f); + // rotate VPN up by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[2].normal, vright, vpn, 90f - r_newrefdef.fov_y / 2f); + // rotate VPN down by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[3].normal, vright, vpn, - (90f - r_newrefdef.fov_y / 2f)); + + for (int i = 0; i < 4; i++) { + frustum[i].type = Defines.PLANE_ANYZ; + frustum[i].dist = Math3D.DotProduct(r_origin, frustum[i].normal); + frustum[i].signbits = (byte) SignbitsForPlane(frustum[i]); + } + } + + // ======================================================================= + + /* + =============== + R_SetupFrame + =============== + */ + void R_SetupFrame() { + int i; + mleaf_t leaf; + + r_framecount++; + + // build the transformation matrix for the given view angles + Math3D.VectorCopy(r_newrefdef.vieworg, r_origin); + + Math3D.AngleVectors(r_newrefdef.viewangles, vpn, vright, vup); + + // current viewcluster + if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) { + r_oldviewcluster = r_viewcluster; + r_oldviewcluster2 = r_viewcluster2; + leaf = Mod_PointInLeaf(r_origin, r_worldmodel); + r_viewcluster = r_viewcluster2 = leaf.cluster; + + // check above and below so crossing solid water doesn't draw wrong + if (leaf.contents == 0) { // look down a bit + float[] temp = { 0, 0, 0 }; + + Math3D.VectorCopy(r_origin, temp); + temp[2] -= 16; + leaf = Mod_PointInLeaf(temp, r_worldmodel); + if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2)) + r_viewcluster2 = leaf.cluster; + } + else { // look up a bit + float[] temp = { 0, 0, 0 }; + + Math3D.VectorCopy(r_origin, temp); + temp[2] += 16; + leaf = Mod_PointInLeaf(temp, r_worldmodel); + if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2)) + r_viewcluster2 = leaf.cluster; + } + } + + for (i = 0; i < 4; i++) + v_blend[i] = r_newrefdef.blend[i]; + + c_brush_polys = 0; + c_alias_polys = 0; + + // clear out the portion of the screen that the NOWORLDMODEL defines + if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) { + gl.glEnable(GL_SCISSOR_TEST); + gl.glClearColor(0.3f, 0.3f, 0.3f, 1.0f); + gl.glScissor( + r_newrefdef.x, + vid.height - r_newrefdef.height - r_newrefdef.y, + r_newrefdef.width, + r_newrefdef.height); + gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + gl.glClearColor(1.0f, 0.0f, 0.5f, 0.5f); + gl.glDisable(GL_SCISSOR_TEST); + } + } + + void MYgluPerspective(double fovy, double aspect, double zNear, double zFar) { + double xmin, xmax, ymin, ymax; + + ymax = zNear * Math.tan(fovy * Math.PI / 360.0); + ymin = -ymax; + + xmin = ymin * aspect; + xmax = ymax * aspect; + + xmin += - (2 * gl_state.camera_separation) / zNear; + xmax += - (2 * gl_state.camera_separation) / zNear; + + gl.glFrustum(xmin, xmax, ymin, ymax, zNear, zFar); + } + + /* + ============= + R_SetupGL + ============= + */ + void R_SetupGL() { + float screenaspect; + int x, x2, y2, y, w, h; + + // + // set up viewport + // + x = (int) Math.floor(r_newrefdef.x * vid.width / vid.width); + x2 = (int) Math.ceil((r_newrefdef.x + r_newrefdef.width) * vid.width / vid.width); + y = (int) Math.floor(vid.height - r_newrefdef.y * vid.height / vid.height); + y2 = (int) Math.ceil(vid.height - (r_newrefdef.y + r_newrefdef.height) * vid.height / vid.height); + + w = x2 - x; + h = y - y2; + + gl.glViewport(x, y2, w, h); + + // + // set up projection matrix + // + screenaspect = (float) r_newrefdef.width / r_newrefdef.height; + gl.glMatrixMode(GL_PROJECTION); + gl.glLoadIdentity(); + MYgluPerspective(r_newrefdef.fov_y, screenaspect, 4, 4096); + + gl.glCullFace(GL_FRONT); + + gl.glMatrixMode(GL_MODELVIEW); + gl.glLoadIdentity(); + + gl.glRotatef(-90, 1, 0, 0); // put Z going up + gl.glRotatef(90, 0, 0, 1); // put Z going up + gl.glRotatef(-r_newrefdef.viewangles[2], 1, 0, 0); + gl.glRotatef(-r_newrefdef.viewangles[0], 0, 1, 0); + gl.glRotatef(-r_newrefdef.viewangles[1], 0, 0, 1); + gl.glTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1], -r_newrefdef.vieworg[2]); + + gl.glGetFloat(GL_MODELVIEW_MATRIX, r_world_matrix); + r_world_matrix.clear(); + + // + // set drawing parms + // + if (gl_cull.value != 0.0f) + gl.glEnable(GL_CULL_FACE); + else + gl.glDisable(GL_CULL_FACE); + + gl.glDisable(GL_BLEND); + gl.glDisable(GL_ALPHA_TEST); + gl.glEnable(GL_DEPTH_TEST); + } + + /* + ============= + R_Clear + ============= + */ + int trickframe = 0; + + void R_Clear() { + if (gl_ztrick.value != 0.0f) { + + if (gl_clear.value != 0.0f) { + gl.glClear(GL_COLOR_BUFFER_BIT); + } + + trickframe++; + if ((trickframe & 1) != 0) { + gldepthmin = 0; + gldepthmax = 0.49999f; + gl.glDepthFunc(GL_LEQUAL); + } + else { + gldepthmin = 1; + gldepthmax = 0.5f; + gl.glDepthFunc(GL_GEQUAL); + } + } + else { + if (gl_clear.value != 0.0f) + gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + else + gl.glClear(GL_DEPTH_BUFFER_BIT); + + gldepthmin = 0; + gldepthmax = 1; + gl.glDepthFunc(GL_LEQUAL); + } + gl.glDepthRange(gldepthmin, gldepthmax); + } + + void R_Flash() { + R_PolyBlend(); + } + + /* + ================ + R_RenderView + + r_newrefdef must be set before the first call + ================ + */ + void R_RenderView(refdef_t fd) { + + if (r_norefresh.value != 0.0f) + return; + + r_newrefdef = fd; + + // included by cwei + if (r_newrefdef == null) { + Com.Error(Defines.ERR_DROP, "R_RenderView: refdef_t fd is null"); + } + + if (r_worldmodel == null && (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) + Com.Error(Defines.ERR_DROP, "R_RenderView: NULL worldmodel"); + + if (r_speeds.value != 0.0f) { + c_brush_polys = 0; + c_alias_polys = 0; + } + + R_PushDlights(); + + if (gl_finish.value != 0.0f) + gl.glFinish(); + + R_SetupFrame(); + + R_SetFrustum(); + + R_SetupGL(); + + R_MarkLeaves(); // done here so we know if we're in water + + R_DrawWorld(); + + R_DrawEntitiesOnList(); + + R_RenderDlights(); + + R_DrawParticles(); + + R_DrawAlphaSurfaces(); + + R_Flash(); + + if (r_speeds.value != 0.0f) { + VID.Printf( + Defines.PRINT_ALL, + "%4i wpoly %4i epoly %i tex %i lmaps\n", + new Vargs(4).add(c_brush_polys).add(c_alias_polys).add(c_visible_textures).add(c_visible_lightmaps)); + } + } + + void R_SetGL2D() { + // set 2D virtual screen size + gl.glViewport(0, 0, vid.width, vid.height); + gl.glMatrixMode(GL_PROJECTION); + gl.glLoadIdentity(); + gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999); + gl.glMatrixMode(GL_MODELVIEW); + gl.glLoadIdentity(); + gl.glDisable(GL_DEPTH_TEST); + gl.glDisable(GL_CULL_FACE); + gl.glDisable(GL_BLEND); + gl.glEnable(GL_ALPHA_TEST); + gl.glColor4f(1, 1, 1, 1); + } + + /* + ==================== + R_SetLightLevel + + ==================== + */ + void R_SetLightLevel() { + float[] shadelight = { 0, 0, 0 }; + + if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) + return; + + // save off light value for server to look at (BIG HACK!) + + R_LightPoint(r_newrefdef.vieworg, shadelight); + + // pick the greatest component, which should be the same + // as the mono value returned by software + if (shadelight[0] > shadelight[1]) { + if (shadelight[0] > shadelight[2]) + r_lightlevel.value = 150 * shadelight[0]; + else + r_lightlevel.value = 150 * shadelight[2]; + } + else { + if (shadelight[1] > shadelight[2]) + r_lightlevel.value = 150 * shadelight[1]; + else + r_lightlevel.value = 150 * shadelight[2]; + } + } + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_RenderFrame + + @@@@@@@@@@@@@@@@@@@@@ + */ + public void R_RenderFrame(refdef_t fd) { + R_RenderView(fd); + R_SetLightLevel(); + R_SetGL2D(); + } + + protected void R_Register() { + r_lefthand = Cvar.Get("hand", "0", Defines.CVAR_USERINFO | Defines.CVAR_ARCHIVE); + r_norefresh = Cvar.Get("r_norefresh", "0", 0); + r_fullbright = Cvar.Get("r_fullbright", "0", 0); + r_drawentities = Cvar.Get("r_drawentities", "1", 0); + r_drawworld = Cvar.Get("r_drawworld", "1", 0); + r_novis = Cvar.Get("r_novis", "0", 0); + r_nocull = Cvar.Get("r_nocull", "0", 0); + r_lerpmodels = Cvar.Get("r_lerpmodels", "1", 0); + r_speeds = Cvar.Get("r_speeds", "0", 0); + + r_lightlevel = Cvar.Get("r_lightlevel", "1", 0); + + gl_nosubimage = Cvar.Get("gl_nosubimage", "0", 0); + gl_allow_software = Cvar.Get("gl_allow_software", "0", 0); + + gl_particle_min_size = Cvar.Get("gl_particle_min_size", "2", Defines.CVAR_ARCHIVE); + gl_particle_max_size = Cvar.Get("gl_particle_max_size", "40", Defines.CVAR_ARCHIVE); + gl_particle_size = Cvar.Get("gl_particle_size", "40", Defines.CVAR_ARCHIVE); + gl_particle_att_a = Cvar.Get("gl_particle_att_a", "0.01", Defines.CVAR_ARCHIVE); + gl_particle_att_b = Cvar.Get("gl_particle_att_b", "0.0", Defines.CVAR_ARCHIVE); + gl_particle_att_c = Cvar.Get("gl_particle_att_c", "0.01", Defines.CVAR_ARCHIVE); + + gl_modulate = Cvar.Get("gl_modulate", "1.5", Defines.CVAR_ARCHIVE); + gl_log = Cvar.Get("gl_log", "0", 0); + gl_bitdepth = Cvar.Get("gl_bitdepth", "0", 0); + gl_mode = Cvar.Get("gl_mode", "1", Defines.CVAR_ARCHIVE); + gl_lightmap = Cvar.Get("gl_lightmap", "0", 0); + gl_shadows = Cvar.Get("gl_shadows", "0", Defines.CVAR_ARCHIVE); + gl_dynamic = Cvar.Get("gl_dynamic", "1", 0); + gl_nobind = Cvar.Get("gl_nobind", "0", 0); + gl_round_down = Cvar.Get("gl_round_down", "1", 0); + gl_picmip = Cvar.Get("gl_picmip", "0", 0); + gl_skymip = Cvar.Get("gl_skymip", "0", 0); + gl_showtris = Cvar.Get("gl_showtris", "0", 0); + gl_ztrick = Cvar.Get("gl_ztrick", "0", 0); + gl_finish = Cvar.Get("gl_finish", "0", Defines.CVAR_ARCHIVE); + gl_clear = Cvar.Get("gl_clear", "0", 0); + gl_cull = Cvar.Get("gl_cull", "1", 0); + gl_polyblend = Cvar.Get("gl_polyblend", "1", 0); + gl_flashblend = Cvar.Get("gl_flashblend", "0", 0); + gl_playermip = Cvar.Get("gl_playermip", "0", 0); + gl_monolightmap = Cvar.Get("gl_monolightmap", "0", 0); + gl_driver = Cvar.Get("gl_driver", "opengl32", Defines.CVAR_ARCHIVE); + gl_texturemode = Cvar.Get("gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST", Defines.CVAR_ARCHIVE); + gl_texturealphamode = Cvar.Get("gl_texturealphamode", "default", Defines.CVAR_ARCHIVE); + gl_texturesolidmode = Cvar.Get("gl_texturesolidmode", "default", Defines.CVAR_ARCHIVE); + gl_lockpvs = Cvar.Get("gl_lockpvs", "0", 0); + + gl_vertex_arrays = Cvar.Get("gl_vertex_arrays", "0", Defines.CVAR_ARCHIVE); + + gl_ext_swapinterval = Cvar.Get("gl_ext_swapinterval", "1", Defines.CVAR_ARCHIVE); + gl_ext_palettedtexture = Cvar.Get("gl_ext_palettedtexture", "0", Defines.CVAR_ARCHIVE); + gl_ext_multitexture = Cvar.Get("gl_ext_multitexture", "1", Defines.CVAR_ARCHIVE); + gl_ext_pointparameters = Cvar.Get("gl_ext_pointparameters", "1", Defines.CVAR_ARCHIVE); + gl_ext_compiled_vertex_array = Cvar.Get("gl_ext_compiled_vertex_array", "1", Defines.CVAR_ARCHIVE); + + gl_drawbuffer = Cvar.Get("gl_drawbuffer", "GL_BACK", 0); + gl_swapinterval = Cvar.Get("gl_swapinterval", "1", Defines.CVAR_ARCHIVE); + + gl_saturatelighting = Cvar.Get("gl_saturatelighting", "0", 0); + + gl_3dlabs_broken = Cvar.Get("gl_3dlabs_broken", "1", Defines.CVAR_ARCHIVE); + + vid_fullscreen = Cvar.Get("vid_fullscreen", "0", Defines.CVAR_ARCHIVE); + vid_gamma = Cvar.Get("vid_gamma", "1.0", Defines.CVAR_ARCHIVE); + vid_ref = Cvar.Get("vid_ref", "jogl", Defines.CVAR_ARCHIVE); + + Cmd.AddCommand("imagelist", new xcommand_t() { + public void execute() { + GL_ImageList_f(); + } + }); + + Cmd.AddCommand("screenshot", new xcommand_t() { + public void execute() { + GL_ScreenShot_f(); + } + }); + Cmd.AddCommand("modellist", new xcommand_t() { + public void execute() { + Mod_Modellist_f(); + } + }); + Cmd.AddCommand("gl_strings", new xcommand_t() { + public void execute() { + GL_Strings_f(); + } + }); + } + + /* + ================== + R_SetMode + ================== + */ + protected boolean R_SetMode() { + + int err; // enum rserr_t + boolean fullscreen; + +// if (vid_fullscreen.modified && !gl_config.allow_cds) { +// VID.Printf(Defines.PRINT_ALL, "R_SetMode() - CDS not allowed with this driver\n"); +// Cvar.SetValue("vid_fullscreen", (vid_fullscreen.value > 0.0f) ? 0.0f : 1.0f); +// vid_fullscreen.modified = false; +// } + + fullscreen = (vid_fullscreen.value > 0.0f); + + vid_fullscreen.modified = false; + gl_mode.modified = false; + + Dimension dim = new Dimension(vid.width, vid.height); + + if ((err = glImpl.setMode(dim, (int) gl_mode.value, fullscreen)) == rserr_ok) { + gl_state.prev_mode = (int) gl_mode.value; + } + else { + if (err == rserr_invalid_fullscreen) { + Cvar.SetValue("vid_fullscreen", 0); + vid_fullscreen.modified = false; + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - fullscreen unavailable in this mode\n"); + if ((err = glImpl.setMode(dim, (int) gl_mode.value, false)) == rserr_ok) + return true; + } + else if (err == rserr_invalid_mode) { + Cvar.SetValue("gl_mode", gl_state.prev_mode); + gl_mode.modified = false; + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - invalid mode\n"); + } + + // try setting it back to something safe + if ((err = glImpl.setMode(dim, gl_state.prev_mode, false)) != rserr_ok) { + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - could not revert to safe mode\n"); + return false; + } + } + return true; + } + + /* + =============== + R_Init + =============== + */ + float[] r_turbsin = new float[256]; + + protected boolean R_Init() { + return R_Init(0, 0); + } + + public boolean R_Init(int vid_xpos, int vid_ypos) { + + assert(Warp.SIN.length == 256) : "warpsin table bug"; + + // fill r_turbsin + for (int j = 0; j < 256; j++) { + r_turbsin[j] = Warp.SIN[j] * 0.5f; + } + + VID.Printf(Defines.PRINT_ALL, "ref_gl version: " + REF_VERSION + '\n'); + + Draw_GetPalette(); + + R_Register(); + + // set our "safe" modes + gl_state.prev_mode = 3; + + // create the window and set up the context + if (!R_SetMode()) { + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_Init() - could not R_SetMode()\n"); + return false; + } + return true; + } + + public boolean R_Init2() { + VID.MenuInit(); + + /* + ** get our various GL strings + */ +// VID.Printf(Defines.PRINT_ALL, "JOGL_VERSION: " + Version.getVersion() + '\n'); + gl_config.vendor_string = gl.glGetString(GL_VENDOR); + VID.Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n'); + gl_config.renderer_string = gl.glGetString(GL_RENDERER); + VID.Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n'); + gl_config.version_string = gl.glGetString(GL_VERSION); + VID.Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n'); + gl_config.extensions_string = gl.glGetString(GL_EXTENSIONS); + VID.Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n'); + + gl_config.parseOpenGLVersion(); + + String renderer_buffer = gl_config.renderer_string.toLowerCase(); + String vendor_buffer = gl_config.vendor_string.toLowerCase(); + + if (renderer_buffer.indexOf("voodoo") >= 0) { + if (renderer_buffer.indexOf("rush") < 0) + gl_config.renderer = GL_RENDERER_VOODOO; + else + gl_config.renderer = GL_RENDERER_VOODOO_RUSH; + } + else if (vendor_buffer.indexOf("sgi") >= 0) + gl_config.renderer = GL_RENDERER_SGI; + else if (renderer_buffer.indexOf("permedia") >= 0) + gl_config.renderer = GL_RENDERER_PERMEDIA2; + else if (renderer_buffer.indexOf("glint") >= 0) + gl_config.renderer = GL_RENDERER_GLINT_MX; + else if (renderer_buffer.indexOf("glzicd") >= 0) + gl_config.renderer = GL_RENDERER_REALIZM; + else if (renderer_buffer.indexOf("gdi") >= 0) + gl_config.renderer = GL_RENDERER_MCD; + else if (renderer_buffer.indexOf("pcx2") >= 0) + gl_config.renderer = GL_RENDERER_PCX2; + else if (renderer_buffer.indexOf("verite") >= 0) + gl_config.renderer = GL_RENDERER_RENDITION; + else + gl_config.renderer = GL_RENDERER_OTHER; + + String monolightmap = gl_monolightmap.string.toUpperCase(); + if (monolightmap.length() < 2 || monolightmap.charAt(1) != 'F') { + if (gl_config.renderer == GL_RENDERER_PERMEDIA2) { + Cvar.Set("gl_monolightmap", "A"); + VID.Printf(Defines.PRINT_ALL, "...using gl_monolightmap 'a'\n"); + } + else if ((gl_config.renderer & GL_RENDERER_POWERVR) != 0) { + Cvar.Set("gl_monolightmap", "0"); + } + else { + Cvar.Set("gl_monolightmap", "0"); + } + } + + // power vr can't have anything stay in the framebuffer, so + // the screen needs to redraw the tiled background every frame + if ((gl_config.renderer & GL_RENDERER_POWERVR) != 0) { + Cvar.Set("scr_drawall", "1"); + } + else { + Cvar.Set("scr_drawall", "0"); + } + + // #ifdef __linux__ + Cvar.SetValue("gl_finish", 1); + // #endif + + // MCD has buffering issues + if (gl_config.renderer == GL_RENDERER_MCD) { + Cvar.SetValue("gl_finish", 1); + } + + if ((gl_config.renderer & GL_RENDERER_3DLABS) != 0) { + if (gl_3dlabs_broken.value != 0.0f) + gl_config.allow_cds = false; + else + gl_config.allow_cds = true; + } + else { + gl_config.allow_cds = true; + } + + if (gl_config.allow_cds) + VID.Printf(Defines.PRINT_ALL, "...allowing CDS\n"); + else + VID.Printf(Defines.PRINT_ALL, "...disabling CDS\n"); + + /* + ** grab extensions + */ + if (gl_config.extensions_string.indexOf("GL_EXT_compiled_vertex_array") >= 0 + || gl_config.extensions_string.indexOf("GL_SGI_compiled_vertex_array") >= 0) { + VID.Printf(Defines.PRINT_ALL, "...enabling GL_EXT_compiled_vertex_array\n"); + // qglLockArraysEXT = ( void * ) qwglGetProcAddress( "glLockArraysEXT" ); + if (gl_ext_compiled_vertex_array.value != 0.0f) + qglLockArraysEXT = true; + else + qglLockArraysEXT = false; + // qglUnlockArraysEXT = ( void * ) qwglGetProcAddress( "glUnlockArraysEXT" ); + //qglUnlockArraysEXT = true; + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n"); + } + + if (gl_config.extensions_string.indexOf("WGL_EXT_swap_control") >= 0) { + qwglSwapIntervalEXT = true; + VID.Printf(Defines.PRINT_ALL, "...enabling WGL_EXT_swap_control\n"); + } else { + qwglSwapIntervalEXT = false; + VID.Printf(Defines.PRINT_ALL, "...WGL_EXT_swap_control not found\n"); + } + + if (gl_config.extensions_string.indexOf("GL_EXT_point_parameters") >= 0) { + if (gl_ext_pointparameters.value != 0.0f) { + // qglPointParameterfEXT = ( void (APIENTRY *)( GLenum, GLfloat ) ) qwglGetProcAddress( "glPointParameterfEXT" ); + qglPointParameterfEXT = true; + // qglPointParameterfvEXT = ( void (APIENTRY *)( GLenum, const GLfloat * ) ) qwglGetProcAddress( "glPointParameterfvEXT" ); + VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_point_parameters\n"); + } + else { + VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_point_parameters\n"); + } + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_EXT_point_parameters not found\n"); + } + + // #ifdef __linux__ + // if ( strstr( gl_config.extensions_string, "3DFX_set_global_palette" )) + // { + // if ( gl_ext_palettedtexture->value ) + // { + // VID.Printf( Defines.PRINT_ALL, "...using 3DFX_set_global_palette\n" ); + // qgl3DfxSetPaletteEXT = ( void ( APIENTRY * ) (GLuint *) )qwglGetProcAddress( "gl3DfxSetPaletteEXT" ); + //// qglColorTableEXT = Fake_glColorTableEXT; + // } + // else + // { + // VID.Printf( Defines.PRINT_ALL, "...ignoring 3DFX_set_global_palette\n" ); + // } + // } + // else + // { + // VID.Printf( Defines.PRINT_ALL, "...3DFX_set_global_palette not found\n" ); + // } + // #endif + + if (!qglColorTableEXT + && gl_config.extensions_string.indexOf("GL_EXT_paletted_texture") >= 0 + && gl_config.extensions_string.indexOf("GL_EXT_shared_texture_palette") >= 0) { + if (gl_ext_palettedtexture.value != 0.0f) { + VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_shared_texture_palette\n"); + qglColorTableEXT = false; // true; TODO jogl bug + } + else { + VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_shared_texture_palette\n"); + qglColorTableEXT = false; + } + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_EXT_shared_texture_palette not found\n"); + } + + if (gl_config.extensions_string.indexOf("GL_ARB_multitexture") >= 0) { + if (gl_ext_multitexture.value != 0.0f) { + VID.Printf(Defines.PRINT_ALL, "...using GL_ARB_multitexture\n"); + // qglMTexCoord2fSGIS = ( void * ) qwglGetProcAddress( "glMultiTexCoord2fARB" ); + // qglActiveTextureARB = ( void * ) qwglGetProcAddress( "glActiveTextureARB" ); + // qglClientActiveTextureARB = ( void * ) qwglGetProcAddress( "glClientActiveTextureARB" ); + qglActiveTextureARB = true; + qglMTexCoord2fSGIS = true; +// GL_TEXTURE0 = GL_TEXTURE0_ARB; +// GL_TEXTURE1 = GL_TEXTURE1_ARB; + Cvar.SetValue("r_fullbright", 1); + } + else { + VID.Printf(Defines.PRINT_ALL, "...ignoring GL_ARB_multitexture\n"); + Cvar.SetValue("r_fullbright", 0); + } + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_ARB_multitexture not found\n"); + Cvar.SetValue("r_fullbright", 0); + } + + if (gl_config.extensions_string.indexOf("GL_SGIS_multitexture") >= 0) { + if (qglActiveTextureARB) { + VID.Printf(Defines.PRINT_ALL, "...GL_SGIS_multitexture deprecated in favor of ARB_multitexture\n"); + Cvar.SetValue("r_fullbright", 1); + } else if (gl_ext_multitexture.value != 0.0f) { + VID.Printf(Defines.PRINT_ALL, "...using GL_SGIS_multitexture\n"); + // qglMTexCoord2fSGIS = ( void * ) qwglGetProcAddress( "glMTexCoord2fSGIS" ); + // qglSelectTextureSGIS = ( void * ) qwglGetProcAddress( "glSelectTextureSGIS" ); + qglSelectTextureSGIS = true; + qglMTexCoord2fSGIS = true; + Cvar.SetValue("r_fullbright", 1); + // //GL_TEXTURE0 = GL_TEXTURE0_SGIS; + // //GL_TEXTURE1 = GL_TEXTURE1_SGIS; + } else { + VID.Printf(Defines.PRINT_ALL, "...ignoring GL_SGIS_multitexture\n"); + Cvar.SetValue("r_fullbright", 0); + } + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_SGIS_multitexture not found\n"); + if (!qglActiveTextureARB) + Cvar.SetValue("r_fullbright", 0); + } + + GL_SetDefaultState(); + + GL_InitImages(); + Mod_Init(); + R_InitParticleTexture(); + Draw_InitLocal(); + + int err = gl.glGetError(); + if (err != GL_NO_ERROR) + VID.Printf( + Defines.PRINT_ALL, + "glGetError() = 0x%x\n\t%s\n", + new Vargs(2).add(err).add("" + gl.glGetString(err))); + + return true; + } + + /* + =============== + R_Shutdown + =============== + */ + public void R_Shutdown() { + Cmd.RemoveCommand("modellist"); + Cmd.RemoveCommand("screenshot"); + Cmd.RemoveCommand("imagelist"); + Cmd.RemoveCommand("gl_strings"); + + Mod_FreeAll(); + + GL_ShutdownImages(); + + /* + * shut down OS specific OpenGL stuff like contexts, etc. + */ + glImpl.shutdown(); + } + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_BeginFrame + @@@@@@@@@@@@@@@@@@@@@ + */ + public void R_BeginFrame(float camera_separation) { + + gl_state.camera_separation = camera_separation; + + /* + ** change modes if necessary + */ + if (gl_mode.modified || vid_fullscreen.modified) { + // FIXME: only restart if CDS is required + cvar_t ref; + + ref = Cvar.Get("vid_ref", "lwjgl", 0); + ref.modified = true; + } + + if (gl_log.modified) { + glImpl.enableLogging((gl_log.value != 0.0f)); + gl_log.modified = false; + } + + if (gl_log.value != 0.0f) { + glImpl.logNewFrame(); + } + + /* + ** update 3Dfx gamma -- it is expected that a user will do a vid_restart + ** after tweaking this value + */ + if (vid_gamma.modified) { + vid_gamma.modified = false; + + if ((gl_config.renderer & GL_RENDERER_VOODOO) != 0) { + // wird erstmal nicht gebraucht + + /* + char envbuffer[1024]; + float g; + + g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F; + Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g ); + putenv( envbuffer ); + Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g ); + putenv( envbuffer ); + */ + VID.Printf(Defines.PRINT_DEVELOPER, "gamma anpassung fuer VOODOO nicht gesetzt"); + } + } + + glImpl.beginFrame(camera_separation); + + /* + ** go into 2D mode + */ + gl.glViewport(0, 0, vid.width, vid.height); + gl.glMatrixMode(GL_PROJECTION); + gl.glLoadIdentity(); + gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999); + gl.glMatrixMode(GL_MODELVIEW); + gl.glLoadIdentity(); + gl.glDisable(GL_DEPTH_TEST); + gl.glDisable(GL_CULL_FACE); + gl.glDisable(GL_BLEND); + gl.glEnable(GL_ALPHA_TEST); + gl.glColor4f(1, 1, 1, 1); + + /* + ** draw buffer stuff + */ + if (gl_drawbuffer.modified) { + gl_drawbuffer.modified = false; + + if (gl_state.camera_separation == 0 || !gl_state.stereo_enabled) { + if (gl_drawbuffer.string.equalsIgnoreCase("GL_FRONT")) + gl.glDrawBuffer(GL_FRONT); + else + gl.glDrawBuffer(GL_BACK); + } + } + + /* + ** texturemode stuff + */ + if (gl_texturemode.modified) { + GL_TextureMode(gl_texturemode.string); + gl_texturemode.modified = false; + } + + if (gl_texturealphamode.modified) { + GL_TextureAlphaMode(gl_texturealphamode.string); + gl_texturealphamode.modified = false; + } + + if (gl_texturesolidmode.modified) { + GL_TextureSolidMode(gl_texturesolidmode.string); + gl_texturesolidmode.modified = false; + } + + /* + ** swapinterval stuff + */ + GL_UpdateSwapInterval(); + + // + // clear screen if desired + // + R_Clear(); + } + + int[] r_rawpalette = new int[256]; + + /* + ============= + R_SetPalette + ============= + */ + public void R_SetPalette(byte[] palette) { + // 256 RGB values (768 bytes) + // or null + int i; + int color = 0; + + if (palette != null) { + int j =0; + for (i = 0; i < 256; i++) { + color = (palette[j++] & 0xFF) << 0; + color |= (palette[j++] & 0xFF) << 8; + color |= (palette[j++] & 0xFF) << 16; + color |= 0xFF000000; + r_rawpalette[i] = color; + } + } + else { + for (i = 0; i < 256; i++) { + r_rawpalette[i] = d_8to24table[i] | 0xff000000; + } + } + GL_SetTexturePalette(r_rawpalette); + + gl.glClearColor(0, 0, 0, 0); + gl.glClear(GL_COLOR_BUFFER_BIT); + gl.glClearColor(1f, 0f, 0.5f, 0.5f); + } + + static final int NUM_BEAM_SEGS = 6; + float[][] start_points = new float[NUM_BEAM_SEGS][3]; + // array of vec3_t + float[][] end_points = new float[NUM_BEAM_SEGS][3]; // array of vec3_t + + /* + ** R_DrawBeam + */ + void R_DrawBeam(entity_t e) { + + int i; + float r, g, b; + + float[] perpvec = { 0, 0, 0 }; // vec3_t + float[] direction = { 0, 0, 0 }; // vec3_t + float[] normalized_direction = { 0, 0, 0 }; // vec3_t + + float[] oldorigin = { 0, 0, 0 }; // vec3_t + float[] origin = { 0, 0, 0 }; // vec3_t + + 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 (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]); + } + + gl.glDisable(GL_TEXTURE_2D); + gl.glEnable(GL_BLEND); + gl.glDepthMask(false); + + r = (d_8to24table[e.skinnum & 0xFF]) & 0xFF; + g = (d_8to24table[e.skinnum & 0xFF] >> 8) & 0xFF; + b = (d_8to24table[e.skinnum & 0xFF] >> 16) & 0xFF; + + r *= 1 / 255.0f; + g *= 1 / 255.0f; + b *= 1 / 255.0f; + + gl.glColor4f(r, g, b, e.alpha); + + gl.glBegin(GL_TRIANGLE_STRIP); + + float[] v; + + for (i = 0; i < NUM_BEAM_SEGS; i++) { + v = start_points[i]; + gl.glVertex3f(v[0], v[1], v[2]); + v = end_points[i]; + gl.glVertex3f(v[0], v[1], v[2]); + v = start_points[(i + 1) % NUM_BEAM_SEGS]; + gl.glVertex3f(v[0], v[1], v[2]); + v = end_points[(i + 1) % NUM_BEAM_SEGS]; + gl.glVertex3f(v[0], v[1], v[2]); + } + gl.glEnd(); + + gl.glEnable(GL_TEXTURE_2D); + gl.glDisable(GL_BLEND); + gl.glDepthMask(true); + } + +} diff --git a/src/jake2/render/basic/Mesh.java b/src/jake2/render/basic/Mesh.java new file mode 100644 index 0000000..724d536 --- /dev/null +++ b/src/jake2/render/basic/Mesh.java @@ -0,0 +1,822 @@ +/* + * Mesh.java + * Copyright (C) 2003 + * + * $Id: Mesh.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.client.VID; +import jake2.client.entity_t; +import jake2.qcommon.qfiles; +import jake2.render.image_t; +import jake2.util.Lib; +import jake2.util.Math3D; + +import java.nio.FloatBuffer; + +/** + * Mesh + * + * @author cwei + */ +public abstract class Mesh extends Light { + + // g_mesh.c: triangle model functions + + /* + * ============================================================= + * + * ALIAS MODELS + * + * ============================================================= + */ + + static final int NUMVERTEXNORMALS = 162; + + float[][] r_avertexnormals = Anorms.VERTEXNORMALS; + + float[][] s_lerped = new float[qfiles.MAX_VERTS][4]; + + float[] shadevector = { 0, 0, 0 }; + + float[] shadelight = { 0, 0, 0 }; + + // precalculated dot products for quantized angles + static final int SHADEDOT_QUANT = 16; + + float[][] r_avertexnormal_dots = Anorms.VERTEXNORMAL_DOTS; + + float[] shadedots = r_avertexnormal_dots[0]; + + void GL_LerpVerts(int nverts, int[] ov, int[] v, + float[][] lerp, float[] move, float[] frontv, float[] backv) { + int i; + int lerpIndex = 0; + + int ovv, vv; + + //PMM -- added RF_SHELL_DOUBLE, RF_SHELL_HALF_DAM + if ((currententity.flags & (Defines.RF_SHELL_RED + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE + | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) { + float[] normal; + for (i = 0; i < nverts; i++ /* , v++, ov++, lerp+=4 */ + ) { + vv = v[i]; + normal = r_avertexnormals[(vv >>> 24) & 0xFF]; + ovv = ov[i]; + + lerp[i][0] = move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) + * frontv[0] + normal[0] * Defines.POWERSUIT_SCALE; + lerp[i][1] = move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) + * frontv[1] + normal[1] * Defines.POWERSUIT_SCALE; + lerp[i][2] = move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) + * frontv[2] + normal[2] * Defines.POWERSUIT_SCALE; + } + } else { + for (i = 0; i < nverts; i++ /* , v++, ov++, lerp+=4 */ + ) { + vv = v[i]; + ovv = ov[i]; + lerp[i][0] = move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) + * frontv[0]; + lerp[i][1] = move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) + * frontv[1]; + lerp[i][2] = move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) + * frontv[2]; + } + } + } + + void GL_LerpVerts(int nverts, int[] ov, int[] v, float[] move, + float[] frontv, float[] backv) { + int lerpIndex = 0; + + int ovv, vv; + FloatBuffer lerp = vertexArrayBuf; + + //PMM -- added RF_SHELL_DOUBLE, RF_SHELL_HALF_DAM + if ((currententity.flags & (Defines.RF_SHELL_RED + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE + | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) { + float[] normal; + int j = 0; + for (int i = 0; i < nverts; i++ /* , v++, ov++, lerp+=4 */ + ) { + vv = v[i]; + normal = r_avertexnormals[(v[i] >>> 24) & 0xFF]; + ovv = ov[i]; + + lerp.put(j, move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) * frontv[0] + + normal[0] * Defines.POWERSUIT_SCALE); + lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) * frontv[1] + + normal[1] * Defines.POWERSUIT_SCALE); + lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) * frontv[2] + + normal[2] * Defines.POWERSUIT_SCALE); + j += 3; + } + } else { + int j = 0; + for (int i = 0; i < nverts; i++ /* , v++, ov++, lerp+=4 */ + ) { + ovv = ov[i]; + vv = v[i]; + + lerp.put(j, move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) * frontv[0]); + lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) * frontv[1]); + lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) * frontv[2]); + j += 3; + } + } + } + + FloatBuffer colorArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 4); + + FloatBuffer vertexArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 3); + + boolean isFilled = false; + + float[] tmpVec = { 0, 0, 0 }; + + /* + * ============= GL_DrawAliasFrameLerp + * + * interpolates between two frames and origins FIXME: batch lerp all + * vertexes ============= + */ + void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, float backlerp) { + float l; + qfiles.daliasframe_t frame, oldframe; + int[] v, ov; + + int[] order; + int orderIndex = 0; + int count; + + float frontlerp; + float alpha; + + float[] move = { 0, 0, 0 }; // vec3_t + float[][] vectors = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } // 3 mal + // vec3_t + }; + + float[] frontv = { 0, 0, 0 }; // vec3_t + float[] backv = { 0, 0, 0 }; // vec3_t + + int i; + int index_xyz; + //float[][] lerp; + + frame = paliashdr.aliasFrames[currententity.frame]; + + v = frame.verts; + + oldframe = paliashdr.aliasFrames[currententity.oldframe]; + + ov = oldframe.verts; + + order = paliashdr.glCmds; + + if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) + alpha = currententity.alpha; + else + alpha = 1.0f; + + // PMM - added double shell + if ((currententity.flags & (Defines.RF_SHELL_RED + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE + | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) + gl.glDisable(GL_TEXTURE_2D); + + frontlerp = 1.0f - backlerp; + + // move should be the delta back to the previous frame * backlerp + Math3D.VectorSubtract(currententity.oldorigin, currententity.origin, + frontv); + Math3D.AngleVectors(currententity.angles, vectors[0], vectors[1], + vectors[2]); + + move[0] = Math3D.DotProduct(frontv, vectors[0]); // forward + move[1] = -Math3D.DotProduct(frontv, vectors[1]); // left + move[2] = Math3D.DotProduct(frontv, vectors[2]); // up + + Math3D.VectorAdd(move, oldframe.translate, move); + + for (i = 0; i < 3; i++) { + move[i] = backlerp * move[i] + frontlerp * frame.translate[i]; + frontv[i] = frontlerp * frame.scale[i]; + backv[i] = backlerp * oldframe.scale[i]; + } + + if (gl_vertex_arrays.value != 0.0f) { + GL_LerpVerts(paliashdr.num_xyz, ov, v, move, frontv, backv); + + gl.glEnableClientState(GL_VERTEX_ARRAY); + gl.glVertexPointer(3, 0, vertexArrayBuf); + + // PMM - added double damage shell + if ((currententity.flags & (Defines.RF_SHELL_RED + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE + | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) { + + gl.glDisableClientState(GL_COLOR_ARRAY); + gl.glColor4f(shadelight[0], shadelight[1], shadelight[2], alpha); + } else { + gl.glEnableClientState(GL_COLOR_ARRAY); + gl.glColorPointer(4, 0, colorArrayBuf); + + // + // pre light everything + // + FloatBuffer color = colorArrayBuf; + int j = 0; + for (i = 0; i < paliashdr.num_xyz; i++) { + // light normal index + l = shadedots[(v[i] >>> 24) & 0xFF]; + color.put(j++, l * shadelight[0]); + color.put(j++, l * shadelight[1]); + color.put(j++, l * shadelight[2]); + color.put(j++, alpha); + } + } + + if (qglLockArraysEXT) + gl.glLockArraysEXT(0, paliashdr.num_xyz); + + while (true) { + // get the vertex count and primitive type + count = order[orderIndex++]; + if (count == 0) + break; // done + if (count < 0) { + count = -count; + gl.glBegin(GL_TRIANGLE_FAN); + } else { + gl.glBegin(GL_TRIANGLE_STRIP); + } + + // PMM - added double damage shell + if ((currententity.flags & (Defines.RF_SHELL_RED + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE + | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) { + do { + index_xyz = order[orderIndex + 2]; + orderIndex += 3; + /* + * vertexArrayBuf.position(4 * index_xyz); + * vertexArrayBuf.get(tmpVec); gl.glVertex3fv( tmpVec ); + */ + gl.glArrayElement(index_xyz); + + } while (--count != 0); + } else { + do { + // texture coordinates come from the draw list + gl.glTexCoord2f(Float + .intBitsToFloat(order[orderIndex + 0]), Float + .intBitsToFloat(order[orderIndex + 1])); + + index_xyz = order[orderIndex + 2]; + orderIndex += 3; + + // normals and vertexes come from the frame list + gl.glArrayElement(index_xyz); + + } while (--count != 0); + } + gl.glEnd(); + } + + if (qglLockArraysEXT) + gl.glUnlockArraysEXT(); + } else { + GL_LerpVerts(paliashdr.num_xyz, ov, v, s_lerped, move, + frontv, backv); + + float[] tmp; + + while (true) { + // get the vertex count and primitive type + count = order[orderIndex++]; + if (count == 0) + break; // done + if (count < 0) { + count = -count; + gl.glBegin(GL_TRIANGLE_FAN); + } else { + gl.glBegin(GL_TRIANGLE_STRIP); + } + + if ((currententity.flags & (Defines.RF_SHELL_RED + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE)) != 0) { + do { + index_xyz = order[orderIndex + 2]; + orderIndex += 3; + + gl.glColor4f(shadelight[0], shadelight[1], + shadelight[2], alpha); + tmp = s_lerped[index_xyz]; + gl.glVertex3f(tmp[0], tmp[1], tmp[2]); + + } while (--count != 0); + } else { + do { + // texture coordinates come from the draw list + // gl.glTexCoord2f (((float *)order)[0], ((float + // *)order)[1]); + + gl.glTexCoord2f(Float + .intBitsToFloat(order[orderIndex + 0]), Float + .intBitsToFloat(order[orderIndex + 1])); + index_xyz = order[orderIndex + 2]; + orderIndex += 3; + + // normals and vertexes come from the frame list + l = shadedots[(v[index_xyz] >>> 24) & 0xFF]; + + gl.glColor4f(l * shadelight[0], l * shadelight[1], l + * shadelight[2], alpha); + tmp = s_lerped[index_xyz]; + gl.glVertex3f(tmp[0], tmp[1], tmp[2]); + } while (--count != 0); + } + gl.glEnd(); + } + } + + // PMM - added double damage shell + if ((currententity.flags & (Defines.RF_SHELL_RED + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE + | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) + gl.glEnable(GL_TEXTURE_2D); + } + + /* + * ============= GL_DrawAliasShadow ============= + */ + void GL_DrawAliasShadow(qfiles.dmdl_t paliashdr, int posenum) { + float[] point = { 0, 0, 0 }; + int count; + qfiles.daliasframe_t frame; + + float lheight = currententity.origin[2] - lightspot[2]; + + frame = paliashdr.aliasFrames[currententity.frame]; + + int[] order = paliashdr.glCmds; + + float height = -lheight + 1.0f; + + int orderIndex = 0; + int index = 0; + + while (true) { + // get the vertex count and primitive type + count = order[orderIndex++]; + if (count == 0) + break; // done + if (count < 0) { + count = -count; + gl.glBegin(GL_TRIANGLE_FAN); + } else + gl.glBegin(GL_TRIANGLE_STRIP); + + do { + // normals and vertexes come from the frame list + /* + * point[0] = verts[order[2]].v[0] * frame.scale[0] + + * frame.translate[0]; point[1] = verts[order[2]].v[1] * + * frame.scale[1] + frame.translate[1]; point[2] = + * verts[order[2]].v[2] * frame.scale[2] + frame.translate[2]; + */ + + if (gl_vertex_arrays.value != 0.0f) { + index = order[orderIndex + 2] * 3; + point[0] = vertexArrayBuf.get(index); + point[1] = vertexArrayBuf.get(index + 1); + point[2] = vertexArrayBuf.get(index + 2); + } else { + Math3D.VectorCopy(s_lerped[order[orderIndex + 2]], point); + } + + point[0] -= shadevector[0] * (point[2] + lheight); + point[1] -= shadevector[1] * (point[2] + lheight); + point[2] = height; + gl.glVertex3f(point[0], point[1], point[2]); + + orderIndex += 3; + + } while (--count != 0); + + gl.glEnd(); + } + } + + /* + * * R_CullAliasModel + */ + boolean R_CullAliasModel(float[][] bbox, entity_t e) { + int i; + float[] mins = { 0, 0, 0 }; + float[] maxs = { 0, 0, 0 }; + + qfiles.dmdl_t paliashdr; + + float[][] vectors = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }; + + float[] thismins = { 0, 0, 0 }; + float[] oldmins = { 0, 0, 0 }; + float[] thismaxs = { 0, 0, 0 }; + float[] oldmaxs = { 0, 0, 0 }; + qfiles.daliasframe_t pframe, poldframe; + float[] angles = { 0, 0, 0 }; + + paliashdr = (qfiles.dmdl_t) currentmodel.extradata; + + if ((e.frame >= paliashdr.num_frames) || (e.frame < 0)) { + VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + + currentmodel.name + ": no such frame " + e.frame + '\n'); + e.frame = 0; + } + if ((e.oldframe >= paliashdr.num_frames) || (e.oldframe < 0)) { + VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + + currentmodel.name + ": no such oldframe " + e.oldframe + + '\n'); + e.oldframe = 0; + } + + pframe = paliashdr.aliasFrames[e.frame]; + poldframe = paliashdr.aliasFrames[e.oldframe]; + + /* + * * compute axially aligned mins and maxs + */ + if (pframe == poldframe) { + for (i = 0; i < 3; i++) { + mins[i] = pframe.translate[i]; + maxs[i] = mins[i] + pframe.scale[i] * 255; + } + } else { + for (i = 0; i < 3; i++) { + thismins[i] = pframe.translate[i]; + thismaxs[i] = thismins[i] + pframe.scale[i] * 255; + + oldmins[i] = poldframe.translate[i]; + oldmaxs[i] = oldmins[i] + poldframe.scale[i] * 255; + + if (thismins[i] < oldmins[i]) + mins[i] = thismins[i]; + else + mins[i] = oldmins[i]; + + if (thismaxs[i] > oldmaxs[i]) + maxs[i] = thismaxs[i]; + else + maxs[i] = oldmaxs[i]; + } + } + + /* + * * compute a full bounding box + */ + for (i = 0; i < 8; i++) { + float[] tmp = { 0, 0, 0 }; + + if ((i & 1) != 0) + tmp[0] = mins[0]; + else + tmp[0] = maxs[0]; + + if ((i & 2) != 0) + tmp[1] = mins[1]; + else + tmp[1] = maxs[1]; + + if ((i & 4) != 0) + tmp[2] = mins[2]; + else + tmp[2] = maxs[2]; + + Math3D.VectorCopy(tmp, bbox[i]); + } + + /* + * * rotate the bounding box + */ + Math3D.VectorCopy(e.angles, angles); + angles[YAW] = -angles[YAW]; + Math3D.AngleVectors(angles, vectors[0], vectors[1], vectors[2]); + + for (i = 0; i < 8; i++) { + float[] tmp = { 0, 0, 0 }; + + Math3D.VectorCopy(bbox[i], tmp); + + bbox[i][0] = Math3D.DotProduct(vectors[0], tmp); + bbox[i][1] = -Math3D.DotProduct(vectors[1], tmp); + bbox[i][2] = Math3D.DotProduct(vectors[2], tmp); + + Math3D.VectorAdd(e.origin, bbox[i], bbox[i]); + } + + { + int p, f; + int aggregatemask = ~0; // 0xFFFFFFFF + + for (p = 0; p < 8; p++) { + int mask = 0; + + for (f = 0; f < 4; f++) { + float dp = Math3D.DotProduct(frustum[f].normal, bbox[p]); + + if ((dp - frustum[f].dist) < 0) { + mask |= (1 << f); + } + } + + aggregatemask &= mask; + } + + if (aggregatemask != 0) { + return true; + } + + return false; + } + } + + /* + * ================= R_DrawAliasModel + * + * ================= + */ + void R_DrawAliasModel(entity_t e) { + int i; + qfiles.dmdl_t paliashdr; + float an; + + // bounding box + float[][] bbox = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, + { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }; + image_t skin; + + if ((e.flags & Defines.RF_WEAPONMODEL) == 0) { + if (R_CullAliasModel(bbox, e)) + return; + } + + if ((e.flags & Defines.RF_WEAPONMODEL) != 0) { + if (r_lefthand.value == 2.0f) + return; + } + + paliashdr = (qfiles.dmdl_t) currentmodel.extradata; + + // + // get lighting information + // + // PMM - rewrote, reordered to handle new shells & mixing + // PMM - 3.20 code .. replaced with original way of doing it to keep mod + // authors happy + // + if ((currententity.flags & (Defines.RF_SHELL_HALF_DAM + | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_RED + | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE)) != 0) { + Math3D.VectorClear(shadelight); + if ((currententity.flags & Defines.RF_SHELL_HALF_DAM) != 0) { + shadelight[0] = 0.56f; + shadelight[1] = 0.59f; + shadelight[2] = 0.45f; + } + if ((currententity.flags & Defines.RF_SHELL_DOUBLE) != 0) { + shadelight[0] = 0.9f; + shadelight[1] = 0.7f; + } + if ((currententity.flags & Defines.RF_SHELL_RED) != 0) + shadelight[0] = 1.0f; + if ((currententity.flags & Defines.RF_SHELL_GREEN) != 0) + shadelight[1] = 1.0f; + if ((currententity.flags & Defines.RF_SHELL_BLUE) != 0) + shadelight[2] = 1.0f; + } + + else if ((currententity.flags & Defines.RF_FULLBRIGHT) != 0) { + for (i = 0; i < 3; i++) + shadelight[i] = 1.0f; + } else { + R_LightPoint(currententity.origin, shadelight); + + // player lighting hack for communication back to server + // big hack! + if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0) { + // pick the greatest component, which should be the same + // as the mono value returned by software + if (shadelight[0] > shadelight[1]) { + if (shadelight[0] > shadelight[2]) + r_lightlevel.value = 150 * shadelight[0]; + else + r_lightlevel.value = 150 * shadelight[2]; + } else { + if (shadelight[1] > shadelight[2]) + r_lightlevel.value = 150 * shadelight[1]; + else + r_lightlevel.value = 150 * shadelight[2]; + } + } + + if (gl_monolightmap.string.charAt(0) != '0') { + float s = shadelight[0]; + + if (s < shadelight[1]) + s = shadelight[1]; + if (s < shadelight[2]) + s = shadelight[2]; + + shadelight[0] = s; + shadelight[1] = s; + shadelight[2] = s; + } + } + + if ((currententity.flags & Defines.RF_MINLIGHT) != 0) { + for (i = 0; i < 3; i++) + if (shadelight[i] > 0.1f) + break; + if (i == 3) { + shadelight[0] = 0.1f; + shadelight[1] = 0.1f; + shadelight[2] = 0.1f; + } + } + + if ((currententity.flags & Defines.RF_GLOW) != 0) { // bonus items will + // pulse with time + float scale; + float min; + + scale = (float) (0.1f * Math.sin(r_newrefdef.time * 7)); + for (i = 0; i < 3; i++) { + min = shadelight[i] * 0.8f; + shadelight[i] += scale; + if (shadelight[i] < min) + shadelight[i] = min; + } + } + + // ================= + // PGM ir goggles color override + if ((r_newrefdef.rdflags & Defines.RDF_IRGOGGLES) != 0 + && (currententity.flags & Defines.RF_IR_VISIBLE) != 0) { + shadelight[0] = 1.0f; + shadelight[1] = 0.0f; + shadelight[2] = 0.0f; + } + // PGM + // ================= + + shadedots = r_avertexnormal_dots[((int) (currententity.angles[1] * (SHADEDOT_QUANT / 360.0))) + & (SHADEDOT_QUANT - 1)]; + + an = (float) (currententity.angles[1] / 180 * Math.PI); + shadevector[0] = (float) Math.cos(-an); + shadevector[1] = (float) Math.sin(-an); + shadevector[2] = 1; + Math3D.VectorNormalize(shadevector); + + // + // locate the proper data + // + + c_alias_polys += paliashdr.num_tris; + + // + // draw all the triangles + // + if ((currententity.flags & Defines.RF_DEPTHHACK) != 0) + // hack the depth range to prevent view model from poking into walls + gl.glDepthRange(gldepthmin, gldepthmin + 0.3 + * (gldepthmax - gldepthmin)); + + if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0 + && (r_lefthand.value == 1.0f)) { + gl.glMatrixMode(GL_PROJECTION); + gl.glPushMatrix(); + gl.glLoadIdentity(); + gl.glScalef(-1, 1, 1); + MYgluPerspective(r_newrefdef.fov_y, (float) r_newrefdef.width + / r_newrefdef.height, 4, 4096); + gl.glMatrixMode(GL_MODELVIEW); + + gl.glCullFace(GL_BACK); + } + + gl.glPushMatrix(); + e.angles[PITCH] = -e.angles[PITCH]; // sigh. + R_RotateForEntity(e); + e.angles[PITCH] = -e.angles[PITCH]; // sigh. + + // select skin + if (currententity.skin != null) + skin = currententity.skin; // custom player skin + else { + if (currententity.skinnum >= qfiles.MAX_MD2SKINS) + skin = currentmodel.skins[0]; + else { + skin = currentmodel.skins[currententity.skinnum]; + if (skin == null) + skin = currentmodel.skins[0]; + } + } + if (skin == null) + skin = r_notexture; // fallback... + GL_Bind(skin.texnum); + + // draw it + + gl.glShadeModel(GL_SMOOTH); + + GL_TexEnv(GL_MODULATE); + if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) { + gl.glEnable(GL_BLEND); + } + + if ((currententity.frame >= paliashdr.num_frames) + || (currententity.frame < 0)) { + VID.Printf(Defines.PRINT_ALL, "R_DrawAliasModel " + + currentmodel.name + ": no such frame " + + currententity.frame + '\n'); + currententity.frame = 0; + currententity.oldframe = 0; + } + + if ((currententity.oldframe >= paliashdr.num_frames) + || (currententity.oldframe < 0)) { + VID.Printf(Defines.PRINT_ALL, "R_DrawAliasModel " + + currentmodel.name + ": no such oldframe " + + currententity.oldframe + '\n'); + currententity.frame = 0; + currententity.oldframe = 0; + } + + if (r_lerpmodels.value == 0.0f) + currententity.backlerp = 0; + GL_DrawAliasFrameLerp(paliashdr, currententity.backlerp); + + GL_TexEnv(GL_REPLACE); + gl.glShadeModel(GL_FLAT); + + gl.glPopMatrix(); + + if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0 + && (r_lefthand.value == 1.0F)) { + gl.glMatrixMode(GL_PROJECTION); + gl.glPopMatrix(); + gl.glMatrixMode(GL_MODELVIEW); + gl.glCullFace(GL_FRONT); + } + + if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) { + gl.glDisable(GL_BLEND); + } + + if ((currententity.flags & Defines.RF_DEPTHHACK) != 0) + gl.glDepthRange(gldepthmin, gldepthmax); + + if (gl_shadows.value != 0.0f + && (currententity.flags & (Defines.RF_TRANSLUCENT | Defines.RF_WEAPONMODEL)) == 0) { + gl.glPushMatrix(); + R_RotateForEntity(e); + gl.glDisable(GL_TEXTURE_2D); + gl.glEnable(GL_BLEND); + gl.glColor4f(0, 0, 0, 0.5f); + GL_DrawAliasShadow(paliashdr, currententity.frame); + gl.glEnable(GL_TEXTURE_2D); + gl.glDisable(GL_BLEND); + gl.glPopMatrix(); + } + gl.glColor4f(1, 1, 1, 1); + } + +}
\ No newline at end of file diff --git a/src/jake2/render/basic/Misc.java b/src/jake2/render/basic/Misc.java new file mode 100644 index 0000000..5e185e2 --- /dev/null +++ b/src/jake2/render/basic/Misc.java @@ -0,0 +1,301 @@ +/* + * Misc.java + * Copyright (C) 2003 + * + * $Id: Misc.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.client.VID; +import jake2.qcommon.FS; +import jake2.qcommon.xcommand_t; +import jake2.util.Lib; + +import java.io.*; +import java.nio.*; +import java.nio.ByteBuffer; +import java.nio.MappedByteBuffer; +import java.nio.channels.FileChannel; + +/** + * Misc + * + * @author cwei + */ +public final class Misc extends Mesh { +//// r_misc.c +// +// #include "gl_local.h" +// + /* + ================== + R_InitParticleTexture + ================== + */ + byte[][] dottexture = + { + {0,0,0,0,0,0,0,0}, + {0,0,1,1,0,0,0,0}, + {0,1,1,1,1,0,0,0}, + {0,1,1,1,1,0,0,0}, + {0,0,1,1,0,0,0,0}, + {0,0,0,0,0,0,0,0}, + {0,0,0,0,0,0,0,0}, + {0,0,0,0,0,0,0,0}, + }; + + void R_InitParticleTexture() + { + int x,y; + byte[] data = new byte[8 * 8 * 4]; + + // + // particle texture + // + for (x=0 ; x<8 ; x++) + { + for (y=0 ; y<8 ; y++) + { + data[y * 32 + x * 4 + 0] = (byte)255; + data[y * 32 + x * 4 + 1] = (byte)255; + data[y * 32 + x * 4 + 2] = (byte)255; + data[y * 32 + x * 4 + 3] = (byte)(dottexture[x][y]*255); + + } + } + r_particletexture = GL_LoadPic("***particle***", data, 8, 8, it_sprite, 32); + + // + // also use this for bad textures, but without alpha + // + for (x=0 ; x<8 ; x++) + { + for (y=0 ; y<8 ; y++) + { + data[y * 32 + x * 4 + 0] = (byte)(dottexture[x&3][y&3]*255); + data[y * 32 + x * 4 + 1] = 0; // dottexture[x&3][y&3]*255; + data[y * 32 + x * 4 + 2] = 0; //dottexture[x&3][y&3]*255; + data[y * 32 + x * 4 + 3] = (byte)255; + } + } + r_notexture = GL_LoadPic("***r_notexture***", data, 8, 8, it_wall, 32); + } + + +// /* +// ============================================================================== +// +// SCREEN SHOTS +// +// ============================================================================== +// */ +// +// typedef struct _TargaHeader { +// unsigned char id_length, colormap_type, image_type; +// unsigned short colormap_index, colormap_length; +// unsigned char colormap_size; +// unsigned short x_origin, y_origin, width, height; +// unsigned char pixel_size, attributes; +// } TargaHeader; + + private final static int TGA_HEADER_SIZE = 18; + + /** + * GL_ScreenShot_f + */ + void GL_ScreenShot_f() { + // TODO don't forget +// if (contextInUse) { +// screenshot_f(); +// } else { +// updateScreen(screenshotCall); +// } + } + + private xcommand_t screenshotCall = new xcommand_t() { + public void execute() { + screenshot_f(); + } + }; + + private void screenshot_f() { + StringBuffer sb = new StringBuffer(FS.Gamedir() + "/scrshot/jake00.tga"); + FS.CreatePath(sb.toString()); + File file = new File(sb.toString()); + // find a valid file name + int i = 0; int offset = sb.length() - 6; + while (file.exists() && i++ < 100) { + sb.setCharAt(offset, (char) ((i/10) + '0')); + sb.setCharAt(offset + 1, (char) ((i%10) + '0')); + file = new File(sb.toString()); + } + if (i == 100) { + VID.Printf(Defines.PRINT_ALL, "Clean up your screenshots\n"); + return; + } + + try { + RandomAccessFile out = new RandomAccessFile(file, "rw"); + FileChannel ch = out.getChannel(); + int fileLength = TGA_HEADER_SIZE + vid.width * vid.height * 3; + out.setLength(fileLength); + MappedByteBuffer image = ch.map(FileChannel.MapMode.READ_WRITE, 0, + fileLength); + + // write the TGA header + image.put(0, (byte) 0).put(1, (byte) 0); + image.put(2, (byte) 2); // uncompressed type + image.put(12, (byte) (vid.width & 0xFF)); // vid.width + image.put(13, (byte) (vid.width >> 8)); // vid.width + image.put(14, (byte) (vid.height & 0xFF)); // vid.height + image.put(15, (byte) (vid.height >> 8)); // vid.height + image.put(16, (byte) 24); // pixel size + + // go to image data position + image.position(TGA_HEADER_SIZE); + // jogl needs a sliced buffer + ByteBuffer rgb = image.slice(); + + // change pixel alignment for reading + if (vid.width % 4 != 0) { + gl.glPixelStorei(GL_PACK_ALIGNMENT, 1); + } + + // OpenGL 1.2+ supports the GL_BGR color format + // check the GL_VERSION to use the TARGA BGR order if possible + // e.g.: 1.5.2 NVIDIA 66.29 + if (gl_config.getOpenGLVersion() >= 1.2f) { + // read the BGR values into the image buffer + gl.glReadPixels(0, 0, vid.width, vid.height, GL_BGR, GL_UNSIGNED_BYTE, rgb); + } else { + // read the RGB values into the image buffer + gl.glReadPixels(0, 0, vid.width, vid.height, GL_RGB, GL_UNSIGNED_BYTE, rgb); + // flip RGB to BGR + byte tmp; + for (i = TGA_HEADER_SIZE; i < fileLength; i += 3) { + tmp = image.get(i); + image.put(i, image.get(i + 2)); + image.put(i + 2, tmp); + } + } + // reset to default alignment + gl.glPixelStorei(GL_PACK_ALIGNMENT, 4); + // close the file channel + ch.close(); + } catch (IOException e) { + VID.Printf(Defines.PRINT_ALL, e.getMessage() + '\n'); + } + + VID.Printf(Defines.PRINT_ALL, "Wrote " + file + '\n'); + } + + /* + ** GL_Strings_f + */ + void GL_Strings_f() { + VID.Printf (Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n'); + VID.Printf (Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n'); + VID.Printf (Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n'); + VID.Printf (Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n'); + } + + /* + ** GL_SetDefaultState + */ + void GL_SetDefaultState() + { + gl.glClearColor(1f,0f, 0.5f , 0.5f); // original quake2 + //gl.glClearColor(0, 0, 0, 0); // replaced with black + gl.glCullFace(GL_FRONT); + gl.glEnable(GL_TEXTURE_2D); + + gl.glEnable(GL_ALPHA_TEST); + gl.glAlphaFunc(GL_GREATER, 0.666f); + + gl.glDisable (GL_DEPTH_TEST); + gl.glDisable (GL_CULL_FACE); + gl.glDisable (GL_BLEND); + + gl.glColor4f (1,1,1,1); + + gl.glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); + gl.glShadeModel (GL_FLAT); + + GL_TextureMode( gl_texturemode.string ); + GL_TextureAlphaMode( gl_texturealphamode.string ); + GL_TextureSolidMode( gl_texturesolidmode.string ); + + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + gl.glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + GL_TexEnv( GL_REPLACE ); + + if ( qglPointParameterfEXT ) + { + //float[] attenuations = { gl_particle_att_a.value, gl_particle_att_b.value, gl_particle_att_c.value }; + FloatBuffer attenuations = Lib.newFloatBuffer(4); + attenuations.put(0,gl_particle_att_a.value); + attenuations.put(1,gl_particle_att_b.value); + attenuations.put(2,gl_particle_att_c.value); + + gl.glEnable( GL_POINT_SMOOTH ); + gl.glPointParameterfEXT( GL_POINT_SIZE_MIN_EXT, gl_particle_min_size.value ); + gl.glPointParameterfEXT( GL_POINT_SIZE_MAX_EXT, gl_particle_max_size.value ); + gl.glPointParameterEXT( GL_DISTANCE_ATTENUATION_EXT, attenuations ); + } + + if ( qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f ) + { + gl.glEnable( GL_SHARED_TEXTURE_PALETTE_EXT ); + + GL_SetTexturePalette( d_8to24table ); + } + + GL_UpdateSwapInterval(); + } + + void GL_UpdateSwapInterval() + { + if ( gl_swapinterval.modified ) + { + gl_swapinterval.modified = false; + if ( !gl_state.stereo_enabled ) + { + if (qwglSwapIntervalEXT) { +// TODO ((WGL)gl).wglSwapIntervalEXT((int)gl_swapinterval.value); + } + } + } + } + + + // ============================================================================ + // remove after impl this methods in jake2.render.jogl package + // ============================================================================ + +} diff --git a/src/jake2/render/basic/Model.java b/src/jake2/render/basic/Model.java new file mode 100644 index 0000000..0ee33ab --- /dev/null +++ b/src/jake2/render/basic/Model.java @@ -0,0 +1,1267 @@ +/* + * Model.java + * Copyright (C) 2003 + * + * $Id: Model.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.client.VID; +import jake2.game.cplane_t; +import jake2.game.cvar_t; +import jake2.qcommon.*; +import jake2.render.*; +import jake2.util.Math3D; +import jake2.util.Vargs; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.Arrays; + +/** + * Model + * + * @author cwei + */ +public abstract class Model extends Surf { + + // models.c -- model loading and caching + + model_t loadmodel; + int modfilelen; + + byte[] mod_novis = new byte[Defines.MAX_MAP_LEAFS/8]; + + static final int MAX_MOD_KNOWN = 512; + model_t[] mod_known = new model_t[MAX_MOD_KNOWN]; + int mod_numknown; + + // the inline * models from the current map are kept seperate + model_t[] mod_inline = new model_t[MAX_MOD_KNOWN]; + + abstract void GL_SubdivideSurface(msurface_t surface); // Warp.java + + /* + =============== + Mod_PointInLeaf + =============== + */ + mleaf_t Mod_PointInLeaf(float[] p, model_t model) + { + mnode_t node; + float d; + cplane_t plane; + + if (model == null || model.nodes == null) + Com.Error (Defines.ERR_DROP, "Mod_PointInLeaf: bad model"); + + node = model.nodes[0]; // root node + while (true) + { + if (node.contents != -1) + return (mleaf_t)node; + + plane = node.plane; + d = Math3D.DotProduct(p, plane.normal) - plane.dist; + if (d > 0) + node = node.children[0]; + else + node = node.children[1]; + } + // never reached + } + + + byte[] decompressed = new byte[Defines.MAX_MAP_LEAFS / 8]; + byte[] model_visibility = new byte[Defines.MAX_MAP_VISIBILITY]; + + /* + =================== + Mod_DecompressVis + =================== + */ + byte[] Mod_DecompressVis(byte[] in, int offset, model_t model) + { + int c; + byte[] out; + int outp, inp; + int row; + + row = (model.vis.numclusters+7)>>3; + out = decompressed; + outp = 0; + inp = offset; + + if (in == null) + { // no vis info, so make all visible + while (row != 0) + { + out[outp++] = (byte)0xFF; + row--; + } + return decompressed; + } + + do + { + if (in[inp] != 0) + { + out[outp++] = in[inp++]; + continue; + } + + c = in[inp + 1] & 0xFF; + inp += 2; + while (c != 0) + { + out[outp++] = 0; + c--; + } + } while (outp < row); + + return decompressed; + } + + /* + ============== + Mod_ClusterPVS + ============== + */ + byte[] Mod_ClusterPVS(int cluster, model_t model) + { + if (cluster == -1 || model.vis == null) + return mod_novis; + //return Mod_DecompressVis( (byte *)model.vis + model.vis.bitofs[cluster][Defines.DVIS_PVS], model); + return Mod_DecompressVis(model_visibility, model.vis.bitofs[cluster][Defines.DVIS_PVS], model); + } + + +// =============================================================================== + + /* + ================ + Mod_Modellist_f + ================ + */ + void Mod_Modellist_f() + { + int i; + model_t mod; + int total; + + total = 0; + VID.Printf(Defines.PRINT_ALL,"Loaded models:\n"); + for (i=0; i < mod_numknown ; i++) + { + mod = mod_known[i]; + if (mod.name.length() == 0) + continue; + + VID.Printf (Defines.PRINT_ALL, "%8i : %s\n", new Vargs(2).add(mod.extradatasize).add(mod.name)); + total += mod.extradatasize; + } + VID.Printf (Defines.PRINT_ALL, "Total resident: " + total +'\n'); + } + + /* + =============== + Mod_Init + =============== + */ + void Mod_Init() + { + // init mod_known + for (int i=0; i < MAX_MOD_KNOWN; i++) { + mod_known[i] = new model_t(); + } + Arrays.fill(mod_novis, (byte)0xff); + } + + byte[] fileBuffer; + + /* + ================== + Mod_ForName + + Loads in a model for the given name + ================== + */ + model_t Mod_ForName(String name, boolean crash) + { + model_t mod = null; + int i; + + if (name == null || name.length() == 0) + Com.Error(Defines.ERR_DROP, "Mod_ForName: NULL name"); + + // + // inline models are grabbed only from worldmodel + // + if (name.charAt(0) == '*') + { + i = Integer.parseInt(name.substring(1)); + if (i < 1 || r_worldmodel == null || i >= r_worldmodel.numsubmodels) + Com.Error (Defines.ERR_DROP, "bad inline model number"); + return mod_inline[i]; + } + + // + // search the currently loaded models + // + for (i=0; i<mod_numknown ; i++) + { + mod = mod_known[i]; + + if (mod.name.length() == 0) + continue; + if (mod.name.equals(name) ) + return mod; + } + + // + // find a free model slot spot + // + for (i=0; i<mod_numknown ; i++) + { + mod = mod_known[i]; + + if (mod.name.length() == 0) + break; // free spot + } + if (i == mod_numknown) + { + if (mod_numknown == MAX_MOD_KNOWN) + Com.Error (Defines.ERR_DROP, "mod_numknown == MAX_MOD_KNOWN"); + mod_numknown++; + mod = mod_known[i]; + } + + mod.name = name; + + // + // load the file + // + fileBuffer = FS.LoadFile(name); + + if (fileBuffer == null) + { + if (crash) + Com.Error(Defines.ERR_DROP, "Mod_NumForName: " + mod.name + " not found"); + + mod.name = ""; + return null; + } + + modfilelen = fileBuffer.length; + + loadmodel = mod; + + // + // fill it in + // + ByteBuffer bb = ByteBuffer.wrap(fileBuffer); + bb.order(ByteOrder.LITTLE_ENDIAN); + + // call the apropriate loader + + bb.mark(); + int ident = bb.getInt(); + + bb.reset(); + + switch (ident) + { + case qfiles.IDALIASHEADER: + Mod_LoadAliasModel(mod, bb); + break; + case qfiles.IDSPRITEHEADER: + Mod_LoadSpriteModel(mod, bb); + break; + case qfiles.IDBSPHEADER: + Mod_LoadBrushModel(mod, bb); + break; + default: + Com.Error(Defines.ERR_DROP,"Mod_NumForName: unknown fileid for " + mod.name); + break; + } + + this.fileBuffer = null; // free it for garbage collection + return mod; + } + + /* + =============================================================================== + + BRUSHMODEL LOADING + + =============================================================================== + */ + + byte[] mod_base; + + + /* + ================= + Mod_LoadLighting + ================= + */ + void Mod_LoadLighting(lump_t l) + { + if (l.filelen == 0) + { + loadmodel.lightdata = null; + return; + } + // memcpy (loadmodel.lightdata, mod_base + l.fileofs, l.filelen); + loadmodel.lightdata = new byte[l.filelen]; + System.arraycopy(mod_base, l.fileofs, loadmodel.lightdata, 0, l.filelen); + } + + + /* + ================= + Mod_LoadVisibility + ================= + */ + void Mod_LoadVisibility(lump_t l) + { + int i; + + if (l.filelen == 0) + { + loadmodel.vis = null; + return; + } + + System.arraycopy(mod_base, l.fileofs, model_visibility, 0, l.filelen); + + ByteBuffer bb = ByteBuffer.wrap(model_visibility, 0, l.filelen); + + loadmodel.vis = new qfiles.dvis_t(bb.order(ByteOrder.LITTLE_ENDIAN)); + + /* done: + memcpy (loadmodel.vis, mod_base + l.fileofs, l.filelen); + + loadmodel.vis.numclusters = LittleLong (loadmodel.vis.numclusters); + for (i=0 ; i<loadmodel.vis.numclusters ; i++) + { + loadmodel.vis.bitofs[i][0] = LittleLong (loadmodel.vis.bitofs[i][0]); + loadmodel.vis.bitofs[i][1] = LittleLong (loadmodel.vis.bitofs[i][1]); + } + */ + } + + + /* + ================= + Mod_LoadVertexes + ================= + */ + void Mod_LoadVertexes(lump_t l) + { + mvertex_t[] vertexes; + int i, count; + + if ( (l.filelen % mvertex_t.DISK_SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / mvertex_t.DISK_SIZE; + + vertexes = new mvertex_t[count]; + + loadmodel.vertexes = vertexes; + loadmodel.numvertexes = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + vertexes[i] = new mvertex_t(bb); + } + } + + /* + ================= + RadiusFromBounds + ================= + */ + float RadiusFromBounds(float[] mins, float[] maxs) + { + float[] corner = {0, 0, 0}; + + for (int i=0 ; i<3 ; i++) + { + corner[i] = Math.abs(mins[i]) > Math.abs(maxs[i]) ? Math.abs(mins[i]) : Math.abs(maxs[i]); + } + return Math3D.VectorLength(corner); + } + + + /* + ================= + Mod_LoadSubmodels + ================= + */ + void Mod_LoadSubmodels(lump_t l) + { + qfiles.dmodel_t in; + mmodel_t[] out; + int i, j, count; + + if ((l.filelen % qfiles.dmodel_t.SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dmodel_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new mmodel_t[count]; + + loadmodel.submodels = out; + loadmodel.numsubmodels = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + in = new qfiles.dmodel_t(bb); + out[i] = new mmodel_t(); + for (j=0 ; j<3 ; j++) + { // spread the mins / maxs by a pixel + out[i].mins[j] = in.mins[j] - 1; + out[i].maxs[j] = in.maxs[j] + 1; + out[i].origin[j] = in.origin[j]; + } + out[i].radius = RadiusFromBounds(out[i].mins, out[i].maxs); + out[i].headnode = in.headnode; + out[i].firstface = in.firstface; + out[i].numfaces = in.numfaces; + } + } + + /* + ================= + Mod_LoadEdges + ================= + */ + void Mod_LoadEdges (lump_t l) + { + medge_t[] edges; + int i, count; + + if ( (l.filelen % medge_t.DISK_SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / medge_t.DISK_SIZE; + // out = Hunk_Alloc ( (count + 1) * sizeof(*out)); + edges = new medge_t[count + 1]; + + loadmodel.edges = edges; + loadmodel.numedges = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + edges[i] = new medge_t(bb); + } + } + + /* + ================= + Mod_LoadTexinfo + ================= + */ + void Mod_LoadTexinfo(lump_t l) + { + texinfo_t in; + mtexinfo_t[] out; + mtexinfo_t step; + int i, j, count; + int next; + String name; + + if ((l.filelen % texinfo_t.SIZE) != 0) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / texinfo_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new mtexinfo_t[count]; + for ( i=0 ; i<count ; i++) { + out[i] = new mtexinfo_t(); + } + + loadmodel.texinfo = out; + loadmodel.numtexinfo = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) { + + in = new texinfo_t(bb); + out[i].vecs = in.vecs; + out[i].flags = in.flags; + next = in.nexttexinfo; + if (next > 0) + out[i].next = loadmodel.texinfo[next]; + else + out[i].next = null; + + name = "textures/" + in.texture + ".wal"; + + out[i].image = GL_FindImage(name, it_wall); + if (out[i].image == null) { + VID.Printf(Defines.PRINT_ALL, "Couldn't load " + name + '\n'); + out[i].image = r_notexture; + } + } + + // count animation frames + for (i=0 ; i<count ; i++) { + out[i].numframes = 1; + for (step = out[i].next ; (step != null) && (step != out[i]) ; step=step.next) + out[i].numframes++; + } + } + + /* + ================ + CalcSurfaceExtents + + Fills in s.texturemins[] and s.extents[] + ================ + */ + void CalcSurfaceExtents(msurface_t s) + { + float[] mins = {0, 0}; + float[] maxs = {0, 0}; + float val; + + int j, e; + mvertex_t v; + int[] bmins = {0, 0}; + int[] bmaxs = {0, 0}; + + mins[0] = mins[1] = 999999; + maxs[0] = maxs[1] = -99999; + + mtexinfo_t tex = s.texinfo; + + for (int i=0 ; i<s.numedges ; i++) + { + e = loadmodel.surfedges[s.firstedge+i]; + if (e >= 0) + v = loadmodel.vertexes[loadmodel.edges[e].v[0]]; + else + v = loadmodel.vertexes[loadmodel.edges[-e].v[1]]; + + for (j=0 ; j<2 ; j++) + { + val = v.position[0] * tex.vecs[j][0] + + v.position[1] * tex.vecs[j][1] + + v.position[2] * tex.vecs[j][2] + + tex.vecs[j][3]; + if (val < mins[j]) + mins[j] = val; + if (val > maxs[j]) + maxs[j] = val; + } + } + + for (int i=0 ; i<2 ; i++) + { + bmins[i] = (int)Math.floor(mins[i]/16); + bmaxs[i] = (int)Math.ceil(maxs[i]/16); + + s.texturemins[i] = (short)(bmins[i] * 16); + s.extents[i] = (short)((bmaxs[i] - bmins[i]) * 16); + + } + } + + /* + ================= + Mod_LoadFaces + ================= + */ + void Mod_LoadFaces (lump_t l) + { + qfiles.dface_t in; + msurface_t[] out; + int i, count, surfnum; + int planenum, side; + int ti; + + if ((l.filelen % qfiles.dface_t.SIZE) != 0) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dface_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new msurface_t[count]; + + loadmodel.surfaces = out; + loadmodel.numsurfaces = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + currentmodel = loadmodel; + + GL_BeginBuildingLightmaps(loadmodel); + + for ( surfnum=0 ; surfnum<count ; surfnum++) + { + in = new qfiles.dface_t(bb); + out[surfnum] = new msurface_t(); + out[surfnum].firstedge = in.firstedge; + out[surfnum].numedges = in.numedges; + out[surfnum].flags = 0; + out[surfnum].polys = null; + + planenum = in.planenum; + side = in.side; + if (side != 0) + out[surfnum].flags |= Defines.SURF_PLANEBACK; + + out[surfnum].plane = loadmodel.planes[planenum]; + + ti = in.texinfo; + if (ti < 0 || ti >= loadmodel.numtexinfo) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: bad texinfo number"); + + out[surfnum].texinfo = loadmodel.texinfo[ti]; + + CalcSurfaceExtents(out[surfnum]); + + // lighting info + + for (i=0 ; i<Defines.MAXLIGHTMAPS ; i++) + out[surfnum].styles[i] = in.styles[i]; + + i = in.lightofs; + if (i == -1) + out[surfnum].samples = null; + else { + ByteBuffer pointer = ByteBuffer.wrap(loadmodel.lightdata); + pointer.position(i); + pointer = pointer.slice(); + pointer.mark(); + out[surfnum].samples = pointer; // subarray + } + + // set the drawing flags + + if ((out[surfnum].texinfo.flags & Defines.SURF_WARP) != 0) + { + out[surfnum].flags |= Defines.SURF_DRAWTURB; + for (i=0 ; i<2 ; i++) + { + out[surfnum].extents[i] = 16384; + out[surfnum].texturemins[i] = -8192; + } + GL_SubdivideSurface(out[surfnum]); // cut up polygon for warps + } + + // create lightmaps and polygons + if ((out[surfnum].texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP)) == 0) + GL_CreateSurfaceLightmap(out[surfnum]); + + if ((out[surfnum].texinfo.flags & Defines.SURF_WARP) == 0) + GL_BuildPolygonFromSurface(out[surfnum]); + + } + GL_EndBuildingLightmaps (); + } + + + /* + ================= + Mod_SetParent + ================= + */ + void Mod_SetParent(mnode_t node, mnode_t parent) + { + node.parent = parent; + if (node.contents != -1) return; + Mod_SetParent(node.children[0], node); + Mod_SetParent(node.children[1], node); + } + + /* + ================= + Mod_LoadNodes + ================= + */ + void Mod_LoadNodes(lump_t l) + { + int i, j, count, p; + qfiles.dnode_t in; + mnode_t[] out; + + if ((l.filelen % qfiles.dnode_t.SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dnode_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new mnode_t[count]; + + loadmodel.nodes = out; + loadmodel.numnodes = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + // initialize the tree array + for ( i=0 ; i<count ; i++) out[i] = new mnode_t(); // do first before linking + + // fill and link the nodes + for ( i=0 ; i<count ; i++) + { + in = new qfiles.dnode_t(bb); + for (j=0 ; j<3 ; j++) + { + out[i].mins[j] = in.mins[j]; + out[i].maxs[j] = in.maxs[j]; + } + + p = in.planenum; + out[i].plane = loadmodel.planes[p]; + + out[i].firstsurface = in.firstface; + out[i].numsurfaces = in.numfaces; + out[i].contents = -1; // differentiate from leafs + + for (j=0 ; j<2 ; j++) + { + p = in.children[j]; + if (p >= 0) + out[i].children[j] = loadmodel.nodes[p]; + else + out[i].children[j] = loadmodel.leafs[-1 - p]; // mleaf_t extends mnode_t + } + } + + Mod_SetParent(loadmodel.nodes[0], null); // sets nodes and leafs + } + + /* + ================= + Mod_LoadLeafs + ================= + */ + void Mod_LoadLeafs(lump_t l) + { + qfiles.dleaf_t in; + mleaf_t[] out; + int i, j, count, p; + + if ((l.filelen % qfiles.dleaf_t.SIZE) != 0) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dleaf_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new mleaf_t[count]; + + loadmodel.leafs = out; + loadmodel.numleafs = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + in = new qfiles.dleaf_t(bb); + out[i] = new mleaf_t(); + for (j=0 ; j<3 ; j++) + { + out[i].mins[j] = in.mins[j]; + out[i].maxs[j] = in.maxs[j]; + + } + + out[i].contents = in.contents; + out[i].cluster = in.cluster; + out[i].area = in.area; + + out[i].setMarkSurface(in.firstleafface, loadmodel.marksurfaces); + out[i].nummarksurfaces = in.numleaffaces; + } + } + + + /* + ================= + Mod_LoadMarksurfaces + ================= + */ + void Mod_LoadMarksurfaces(lump_t l) + { + int i, j, count; + + msurface_t[] out; + + if ((l.filelen % Defines.SIZE_OF_SHORT) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + count = l.filelen / Defines.SIZE_OF_SHORT; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new msurface_t[count]; + + loadmodel.marksurfaces = out; + loadmodel.nummarksurfaces = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + j = bb.getShort(); + if (j < 0 || j >= loadmodel.numsurfaces) + Com.Error(Defines.ERR_DROP, "Mod_ParseMarksurfaces: bad surface number"); + + out[i] = loadmodel.surfaces[j]; + } + } + + + /* + ================= + Mod_LoadSurfedges + ================= + */ + void Mod_LoadSurfedges(lump_t l) + { + int i, count; + int[] offsets; + + if ( (l.filelen % Defines.SIZE_OF_INT) != 0) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / Defines.SIZE_OF_INT; + if (count < 1 || count >= Defines.MAX_MAP_SURFEDGES) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: bad surfedges count in " + loadmodel.name + ": " + count); + + offsets = new int[count]; + + loadmodel.surfedges = offsets; + loadmodel.numsurfedges = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) offsets[i] = bb.getInt(); + } + + + /* + ================= + Mod_LoadPlanes + ================= + */ + void Mod_LoadPlanes(lump_t l) + { + int i, j; + cplane_t[] out; + qfiles.dplane_t in; + int count; + int bits; + + if ((l.filelen % qfiles.dplane_t.SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dplane_t.SIZE; + // out = Hunk_Alloc ( count*2*sizeof(*out)); + out = new cplane_t[count * 2]; + + loadmodel.planes = out; + loadmodel.numplanes = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + bits = 0; + in = new qfiles.dplane_t(bb); + out[i] = new cplane_t(); + for (j=0 ; j<3 ; j++) + { + out[i].normal[j] = in.normal[j]; + if (out[i].normal[j] < 0) + bits |= (1<<j); + } + + out[i].dist = in.dist; + out[i].type = (byte)in.type; + out[i].signbits = (byte)bits; + } + } + + /* + ================= + Mod_LoadBrushModel + ================= + */ + void Mod_LoadBrushModel(model_t mod, ByteBuffer buffer) + { + int i; + qfiles.dheader_t header; + mmodel_t bm; + + loadmodel.type = mod_brush; + if (loadmodel != mod_known[0]) + Com.Error(Defines.ERR_DROP, "Loaded a brush model after the world"); + + header = new qfiles.dheader_t(buffer); + + i = header.version; + if (i != Defines.BSPVERSION) + Com.Error (Defines.ERR_DROP, "Mod_LoadBrushModel: " + mod.name + " has wrong version number (" + i + " should be " + Defines.BSPVERSION + ")"); + + mod_base = fileBuffer; //(byte *)header; + + // load into heap + Mod_LoadVertexes(header.lumps[Defines.LUMP_VERTEXES]); // ok + Mod_LoadEdges(header.lumps[Defines.LUMP_EDGES]); // ok + Mod_LoadSurfedges(header.lumps[Defines.LUMP_SURFEDGES]); // ok + Mod_LoadLighting(header.lumps[Defines.LUMP_LIGHTING]); // ok + Mod_LoadPlanes(header.lumps[Defines.LUMP_PLANES]); // ok + Mod_LoadTexinfo(header.lumps[Defines.LUMP_TEXINFO]); // ok + Mod_LoadFaces(header.lumps[Defines.LUMP_FACES]); // ok + Mod_LoadMarksurfaces(header.lumps[Defines.LUMP_LEAFFACES]); + Mod_LoadVisibility(header.lumps[Defines.LUMP_VISIBILITY]); // ok + Mod_LoadLeafs(header.lumps[Defines.LUMP_LEAFS]); // ok + Mod_LoadNodes(header.lumps[Defines.LUMP_NODES]); // ok + Mod_LoadSubmodels(header.lumps[Defines.LUMP_MODELS]); + mod.numframes = 2; // regular and alternate animation + + // + // set up the submodels + // + model_t starmod; + + for (i=0 ; i<mod.numsubmodels ; i++) + { + + bm = mod.submodels[i]; + starmod = mod_inline[i] = loadmodel.copy(); + + starmod.firstmodelsurface = bm.firstface; + starmod.nummodelsurfaces = bm.numfaces; + starmod.firstnode = bm.headnode; + if (starmod.firstnode >= loadmodel.numnodes) + Com.Error(Defines.ERR_DROP, "Inline model " + i + " has bad firstnode"); + + Math3D.VectorCopy(bm.maxs, starmod.maxs); + Math3D.VectorCopy(bm.mins, starmod.mins); + starmod.radius = bm.radius; + + if (i == 0) + loadmodel = starmod.copy(); + + starmod.numleafs = bm.visleafs; + } + } + + /* + ============================================================================== + + ALIAS MODELS + + ============================================================================== + */ + + /* + ================= + Mod_LoadAliasModel + ================= + */ + void Mod_LoadAliasModel (model_t mod, ByteBuffer buffer) + { + int i, j; + qfiles.dmdl_t pheader; + qfiles.dstvert_t[] poutst; + qfiles.dtriangle_t[] pouttri; + qfiles.daliasframe_t[] poutframe; + int[] poutcmd; + + pheader = new qfiles.dmdl_t(buffer); + + if (pheader.version != qfiles.ALIAS_VERSION) + Com.Error(Defines.ERR_DROP, "%s has wrong version number (%i should be %i)", + new Vargs(3).add(mod.name).add(pheader.version).add(qfiles.ALIAS_VERSION)); + + if (pheader.skinheight > MAX_LBM_HEIGHT) + Com.Error(Defines.ERR_DROP, "model "+ mod.name +" has a skin taller than " + MAX_LBM_HEIGHT); + + if (pheader.num_xyz <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no vertices"); + + if (pheader.num_xyz > qfiles.MAX_VERTS) + Com.Error(Defines.ERR_DROP, "model " + mod.name +" has too many vertices"); + + if (pheader.num_st <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no st vertices"); + + if (pheader.num_tris <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no triangles"); + + if (pheader.num_frames <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no frames"); + + // + // load base s and t vertices (not used in gl version) + // + poutst = new qfiles.dstvert_t[pheader.num_st]; + buffer.position(pheader.ofs_st); + for (i=0 ; i<pheader.num_st ; i++) + { + poutst[i] = new qfiles.dstvert_t(buffer); + } + + // + // load triangle lists + // + pouttri = new qfiles.dtriangle_t[pheader.num_tris]; + buffer.position(pheader.ofs_tris); + for (i=0 ; i<pheader.num_tris ; i++) + { + pouttri[i] = new qfiles.dtriangle_t(buffer); + } + + // + // load the frames + // + poutframe = new qfiles.daliasframe_t[pheader.num_frames]; + buffer.position(pheader.ofs_frames); + for (i=0 ; i<pheader.num_frames ; i++) + { + poutframe[i] = new qfiles.daliasframe_t(buffer); + // verts are all 8 bit, so no swapping needed + poutframe[i].verts = new int[pheader.num_xyz]; + for (int k=0; k < pheader.num_xyz; k++) { + poutframe[i].verts[k] = buffer.getInt(); + } + } + + mod.type = mod_alias; + + // + // load the glcmds + // + poutcmd = new int[pheader.num_glcmds]; + buffer.position(pheader.ofs_glcmds); + for (i=0 ; i<pheader.num_glcmds ; i++) + poutcmd[i] = buffer.getInt(); // LittleLong (pincmd[i]); + + // register all skins + String[] skinNames = new String[pheader.num_skins]; + byte[] nameBuf = new byte[qfiles.MAX_SKINNAME]; + buffer.position(pheader.ofs_skins); + for (i=0 ; i<pheader.num_skins ; i++) + { + buffer.get(nameBuf); + skinNames[i] = new String(nameBuf).trim(); + mod.skins[i] = GL_FindImage(skinNames[i], it_skin); + } + + // set the model arrays + pheader.skinNames = skinNames; // skin names + pheader.stVerts = poutst; // textur koordinaten + pheader.triAngles = pouttri; // dreiecke + pheader.glCmds = poutcmd; // STRIP or FAN + pheader.aliasFrames = poutframe; // frames mit vertex array + + mod.extradata = pheader; + + mod.mins[0] = -32; + mod.mins[1] = -32; + mod.mins[2] = -32; + mod.maxs[0] = 32; + mod.maxs[1] = 32; + mod.maxs[2] = 32; + } + + /* + ============================================================================== + + SPRITE MODELS + + ============================================================================== + */ + + /* + ================= + Mod_LoadSpriteModel + ================= + */ + void Mod_LoadSpriteModel(model_t mod, ByteBuffer buffer) + { + qfiles.dsprite_t sprout = new qfiles.dsprite_t(buffer); + + if (sprout.version != qfiles.SPRITE_VERSION) + Com.Error(Defines.ERR_DROP, "%s has wrong version number (%i should be %i)", + new Vargs(3).add(mod.name).add(sprout.version).add(qfiles.SPRITE_VERSION)); + + if (sprout.numframes > qfiles.MAX_MD2SKINS) + Com.Error(Defines.ERR_DROP, "%s has too many frames (%i > %i)", + new Vargs(3).add(mod.name).add(sprout.numframes).add(qfiles.MAX_MD2SKINS)); + + for (int i=0 ; i<sprout.numframes ; i++) + { + mod.skins[i] = GL_FindImage(sprout.frames[i].name, it_sprite); + } + + mod.type = mod_sprite; + mod.extradata = sprout; + } + +// ============================================================================= + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_BeginRegistration + + Specifies the model that will be used as the world + @@@@@@@@@@@@@@@@@@@@@ + */ + public void R_BeginRegistration(String model) + { + cvar_t flushmap; + + Polygon.reset(); + + registration_sequence++; + r_oldviewcluster = -1; // force markleafs + + String fullname = "maps/" + model + ".bsp"; + + // explicitly free the old map if different + // this guarantees that mod_known[0] is the world map + flushmap = Cvar.Get("flushmap", "0", 0); + if ( !mod_known[0].name.equals(fullname) || flushmap.value != 0.0f) + Mod_Free(mod_known[0]); + r_worldmodel = Mod_ForName(fullname, true); + + r_viewcluster = -1; + } + + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_RegisterModel + + @@@@@@@@@@@@@@@@@@@@@ + */ + public model_t R_RegisterModel(String name) + { + model_t mod = null; + int i; + qfiles.dsprite_t sprout; + qfiles.dmdl_t pheader; + + mod = Mod_ForName(name, false); + if (mod != null) + { + mod.registration_sequence = registration_sequence; + + // register any images used by the models + if (mod.type == mod_sprite) + { + sprout = (qfiles.dsprite_t)mod.extradata; + for (i=0 ; i<sprout.numframes ; i++) + mod.skins[i] = GL_FindImage(sprout.frames[i].name, it_sprite); + } + else if (mod.type == mod_alias) + { + pheader = (qfiles.dmdl_t)mod.extradata; + for (i=0 ; i<pheader.num_skins ; i++) + mod.skins[i] = GL_FindImage(pheader.skinNames[i], it_skin); + // PGM + mod.numframes = pheader.num_frames; + // PGM + } + else if (mod.type == mod_brush) + { + for (i=0 ; i<mod.numtexinfo ; i++) + mod.texinfo[i].image.registration_sequence = registration_sequence; + } + } + return mod; + } + + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_EndRegistration + + @@@@@@@@@@@@@@@@@@@@@ + */ + public void R_EndRegistration() + { + model_t mod; + + for (int i=0; i<mod_numknown ; i++) + { + mod = mod_known[i]; + if (mod.name.length() == 0) + continue; + if (mod.registration_sequence != registration_sequence) + { // don't need this model + Mod_Free(mod); + } + } + GL_FreeUnusedImages(); + } + + +// ============================================================================= + + + /* + ================ + Mod_Free + ================ + */ + void Mod_Free (model_t mod) + { + mod.clear(); + } + + /* + ================ + Mod_FreeAll + ================ + */ + void Mod_FreeAll() + { + for (int i=0 ; i<mod_numknown ; i++) + { + if (mod_known[i].extradata != null) + Mod_Free(mod_known[i]); + } + } + + +} diff --git a/src/jake2/render/basic/Polygon.java b/src/jake2/render/basic/Polygon.java new file mode 100644 index 0000000..3fafa69 --- /dev/null +++ b/src/jake2/render/basic/Polygon.java @@ -0,0 +1,145 @@ +/* + * Polygon.java + * Copyright (C) 2003 + * + * $Id: Polygon.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.render.glpoly_t; + +/** + * Polygon + * + * @author cwei + */ +public final class Polygon extends glpoly_t { + + private final static int MAXPOLYS = 20000; + + private final static int MAX_BUFFER_VERTICES = 120000; + + private static float[] buffer = new float[MAX_BUFFER_VERTICES * STRIDE]; + + private static int bufferIndex = 0; + + private static int polyCount = 0; + + private static Polygon[] polyCache = new Polygon[MAXPOLYS]; + static { + for (int i = 0; i < polyCache.length; i++) { + polyCache[i] = new Polygon(); + } + } + + public static glpoly_t create(int numverts) { + Polygon poly = polyCache[polyCount++]; + poly.clear(); + poly.numverts = numverts; + poly.pos = bufferIndex; + bufferIndex += numverts; + return poly; + } + + public static void reset() { + polyCount = 0; + bufferIndex = 0; + } + + private Polygon() { + } + + private final void clear() { + next = null; + chain = null; + numverts = 0; + flags = 0; + } + + public final float x(int index) { + return buffer[offset(index)]; + } + + public final void x(int index, float value) { + buffer[offset(index)] = value; + } + + public final float y(int index) { + return buffer[offset(index) + 1]; + } + + public final void y(int index, float value) { + buffer[offset(index) + 1] = value; + } + + public final float z(int index) { + return buffer[offset(index) + 2]; + } + + public final void z(int index, float value) { + buffer[offset(index) + 2] = value; + } + + public final float s1(int index) { + return buffer[offset(index) + 3]; + } + + public final void s1(int index, float value) { + buffer[offset(index) + 3] = value; + } + + public final float t1(int index) { + return buffer[offset(index) + 4]; + } + + public final void t1(int index, float value) { + buffer[offset(index) + 4] = value; + } + + public final float s2(int index) { + return buffer[offset(index) + 5]; + } + + public final void s2(int index, float value) { + buffer[offset(index) + 5] = value; + } + + public final float t2(int index) { + return buffer[offset(index) + 6]; + } + + public final void t2(int index, float value) { + buffer[offset(index) + 6] = value; + } + + public final void beginScrolling(float value) { + // not in use + } + + public final void endScrolling() { + // not in use + } + + private final int offset(int index) { + return (index + pos) * STRIDE; + } +} diff --git a/src/jake2/render/basic/Surf.java b/src/jake2/render/basic/Surf.java new file mode 100644 index 0000000..31ecf24 --- /dev/null +++ b/src/jake2/render/basic/Surf.java @@ -0,0 +1,1690 @@ +/* + * Surf.java + * Copyright (C) 2003 + * + * $Id: Surf.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.client.*; +import jake2.game.cplane_t; +import jake2.qcommon.Com; +import jake2.render.*; +import jake2.util.Lib; +import jake2.util.Math3D; + +import java.nio.ByteOrder; +import java.nio.IntBuffer; +import java.util.Arrays; + +/** + * 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_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 + IntBuffer lightmap_buffer = Lib.newIntBuffer(BLOCK_WIDTH * BLOCK_HEIGHT, ByteOrder.LITTLE_ENDIAN); + + + public gllightmapstate_t() { + for (int i = 0; i < MAX_LIGHTMAPS; i++) + lightmap_surfaces[i] = new msurface_t(); + } + + public void clearLightmapSurfaces() { + for (int i = 0; i < MAX_LIGHTMAPS; i++) + // TODO lightmap_surfaces[i].clear(); + 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, IntBuffer 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) + { + gl.glBegin(GL_POLYGON); + for (int i=0 ; i<p.numverts ; i++) + { + gl.glTexCoord2f(p.s1(i), p.t1(i)); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + gl.glEnd(); + } + + // ============ + // PGM + /* + ================ + DrawGLFlowingPoly -- version of DrawGLPoly that handles scrolling texture + ================ + */ + void DrawGLFlowingPoly(msurface_t fa) + { + float scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) ); + if(scroll == 0.0f) + scroll = -64.0f; + + gl.glBegin (GL_POLYGON); + glpoly_t p = fa.polys; + for (int i=0 ; i<p.numverts ; i++) + { + gl.glTexCoord2f(p.s1(i) + scroll, p.t1(i)); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + gl.glEnd (); + } + // PGM + // ============ + + /* + ** R_DrawTriangleOutlines + */ + void R_DrawTriangleOutlines() + { + if (gl_showtris.value == 0) + return; + + gl.glDisable (GL_TEXTURE_2D); + gl.glDisable (GL_DEPTH_TEST); + gl.glColor4f (1,1,1,1); + + for (int i=0 ; i<MAX_LIGHTMAPS ; i++) + { + msurface_t surf; + + for ( surf = gl_lms.lightmap_surfaces[i]; surf != null; surf = surf.lightmapchain ) + { + glpoly_t p = surf.polys; + for ( ; p != null ; p=p.chain) + { + for (int j=2 ; j<p.numverts ; j++ ) + { + gl.glBegin (GL_LINE_STRIP); + gl.glVertex3f(p.x(0), p.y(0), p.z(0)); + gl.glVertex3f(p.x(j-1), p.y(j-1), p.z(j-1)); + gl.glVertex3f(p.x(j), p.y(j), p.z(j)); + gl.glVertex3f(p.x(0), p.y(0), p.z(0)); + gl.glEnd (); + } + } + } + } + gl.glEnable (GL_DEPTH_TEST); + gl.glEnable (GL_TEXTURE_2D); + } + + /* + ** DrawGLPolyChain + */ + void DrawGLPolyChain( glpoly_t p, float soffset, float toffset ) + { + if ( soffset == 0 && toffset == 0 ) + { + for ( ; p != null; p = p.chain ) + { + gl.glBegin(GL_POLYGON); + for (int j=0 ; j<p.numverts ; j++) + { + gl.glTexCoord2f (p.s2(j), p.t2(j)); + gl.glVertex3f(p.x(j), p.y(j), p.z(j)); + } + gl.glEnd(); + } + } + else + { + for ( ; p != null; p = p.chain ) + { + gl.glBegin(GL_POLYGON); + for (int j=0 ; j<p.numverts ; j++) + { + gl.glTexCoord2f (p.s2(j) - soffset, p.t2(j) - toffset); + gl.glVertex3f(p.x(j), p.y(j), p.z(j)); + } + 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_BLEND); + + if ( gl_saturatelighting.value != 0) + { + gl.glBlendFunc( GL_ONE, GL_ONE ); + } + else + { + char format = gl_monolightmap.string.toUpperCase().charAt(0); + if ( format != '0' ) + { + switch ( format ) + { + case 'I': + gl.glBlendFunc(GL_ZERO, GL_SRC_COLOR ); + break; + case 'L': + gl.glBlendFunc(GL_ZERO, GL_SRC_COLOR ); + break; + case 'A': + default: + gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + break; + } + } + else + { + gl.glBlendFunc(GL_ZERO, 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; + IntBuffer base; + + smax = (surf.extents[0]>>4)+1; + tmax = (surf.extents[1]>>4)+1; + + pos_t lightPos = new pos_t(surf.dlight_s, surf.dlight_t); + + if ( LM_AllocBlock( smax, tmax, lightPos) ) + { + // kopiere die koordinaten zurueck + surf.dlight_s = lightPos.x; + surf.dlight_t = lightPos.y; + + base = gl_lms.lightmap_buffer; + base.position(surf.dlight_t * BLOCK_WIDTH + surf.dlight_s ); + + R_BuildLightMap (surf, base.slice(), BLOCK_WIDTH); + } + 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 != null ) + DrawGLPolyChain( drawsurf.polys, + ( drawsurf.light_s - drawsurf.dlight_s ) * ( 1.0f / 128.0f ), + ( drawsurf.light_t - drawsurf.dlight_t ) * ( 1.0f / 128.0f ) ); + } + + newdrawsurf = drawsurf; + + // clear the block + LM_InitBlock(); + + // try uploading the block now + if ( !LM_AllocBlock( smax, tmax, lightPos) ) + { + Com.Error( Defines.ERR_FATAL, "Consecutive calls to LM_AllocBlock(" + smax + "," + tmax + ") failed (dynamic)\n"); + } + + // kopiere die koordinaten zurueck + surf.dlight_s = lightPos.x; + surf.dlight_t = lightPos.y; + + base = gl_lms.lightmap_buffer; + base.position(surf.dlight_t * BLOCK_WIDTH + surf.dlight_s ); + + R_BuildLightMap (surf, base.slice(), BLOCK_WIDTH); + } + } + + /* + ** 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_BLEND); + gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl.glDepthMask( true ); + } + + private IntBuffer temp2 = Lib.newIntBuffer(34 * 34, ByteOrder.LITTLE_ENDIAN); + + /* + ================ + 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_MODULATE ); + gl.glColor4f( gl_state.inverse_intensity, + gl_state.inverse_intensity, + gl_state.inverse_intensity, + 1.0F ); + EmitWaterPolys (fa); + GL_TexEnv( GL_REPLACE ); + + return; + } + else + { + GL_Bind( image.texnum ); + GL_TexEnv( GL_REPLACE ); + } + + // ====== + // PGM + if((fa.texinfo.flags & Defines.SURF_FLOWING) != 0) + DrawGLFlowingPoly(fa); + else + DrawGLPoly (fa.polys); + // PGM + // ====== + + // ersetzt goto + boolean gotoDynamic = false; + /* + ** check for lightmap modification + */ + for ( maps = 0; maps < Defines.MAXLIGHTMAPS && fa.styles[maps] != (byte)255; maps++ ) + { + if ( r_newrefdef.lightstyles[fa.styles[maps] & 0xFF].white != fa.cached_light[maps] ) { + gotoDynamic = true; + break; + } + } + + // this is a hack from cwei + if (maps == 4) maps--; + + // dynamic this frame or dynamic previously + if ( gotoDynamic || ( fa.dlightframe == r_framecount ) ) + { + // label dynamic: + if ( gl_dynamic.value != 0 ) + { + if (( fa.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP ) ) == 0) + { + is_dynamic = true; + } + } + } + + if ( is_dynamic ) + { + if ( ( (fa.styles[maps] & 0xFF) >= 32 || fa.styles[maps] == 0 ) && ( fa.dlightframe != r_framecount ) ) + { + // ist ersetzt durch temp2: unsigned temp[34*34]; + int smax, tmax; + + smax = (fa.extents[0]>>4)+1; + tmax = (fa.extents[1]>>4)+1; + + R_BuildLightMap( fa, temp2, smax); + R_SetCacheState( fa ); + + GL_Bind( gl_state.lightmap_textures + fa.lightmaptexturenum ); + + gl.glTexSubImage2D( GL_TEXTURE_2D, 0, + fa.light_s, fa.light_t, + smax, tmax, + GL_LIGHTMAP_FORMAT, + GL_UNSIGNED_BYTE, temp2 ); + + 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 + // + r_world_matrix.clear(); + gl.glLoadMatrix(r_world_matrix); + + gl.glEnable (GL_BLEND); + GL_TexEnv(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_REPLACE ); + gl.glColor4f (1,1,1,1); + gl.glDisable (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_REPLACE ); + } + + // direct buffer + private IntBuffer temp = Lib.newIntBuffer(128 * 128, ByteOrder.LITTLE_ENDIAN); + + 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; + + // ersetzt goto + boolean gotoDynamic = false; + + 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] ) { + gotoDynamic = true; + break; + } + } + + // this is a hack from cwei + if (map == 4) map--; + + // dynamic this frame or dynamic previously + if ( gotoDynamic || ( surf.dlightframe == r_framecount ) ) + { + // label dynamic: + if ( gl_dynamic.value != 0 ) + { + if ( (surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP )) == 0 ) + { + is_dynamic = true; + } + } + } + + if ( is_dynamic ) + { + // ist raus gezogen worden int[] temp = new int[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, temp, smax); + 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, temp, smax); + + 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_POLYGON); + for (i=0 ; i< nv; i++) + { + gl.glMultiTexCoord2f(GL_TEXTURE0, p.s1(i) + scroll, p.t1(i)); + gl.glMultiTexCoord2f(GL_TEXTURE1, p.s2(i), p.t2(i)); + //gglMTexCoord2fSGIS( GL_TEXTURE0, v[3] + scroll, v[4]); + //gglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + gl.glEnd (); + } + } + else + { + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glBegin (GL_POLYGON); + for (i=0 ; i< nv; i++) + { + gl.glMultiTexCoord2f(GL_TEXTURE0, p.s1(i), p.t1(i)); + gl.glMultiTexCoord2f(GL_TEXTURE1, p.s2(i), p.t2(i)); + //gglMTexCoord2fSGIS( GL_TEXTURE0, v[3], v[4]); + //gglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + 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_POLYGON); + for (i=0 ; i< nv; i++) + { + gl.glMultiTexCoord2f(GL_TEXTURE0, p.s1(i) + scroll, p.t1(i)); + gl.glMultiTexCoord2f(GL_TEXTURE1, p.s2(i), p.t2(i)); + //gglMTexCoord2fSGIS( GL_TEXTURE0, v[3] + scroll, v[4]); + //gglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + gl.glEnd(); + } + } + else + { + // PGM + // ========== + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glBegin (GL_POLYGON); + for (i=0 ; i< nv; i++) + { + gl.glMultiTexCoord2f(GL_TEXTURE0, p.s1(i), p.t1(i)); + gl.glMultiTexCoord2f(GL_TEXTURE1, p.s2(i), p.t2(i)); + //gglMTexCoord2fSGIS( GL_TEXTURE0, v[3], v[4]); + //gglMTexCoord2fSGIS( GL_TEXTURE1, v[5], v[6]); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + 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_BLEND); + gl.glColor4f (1,1,1,0.25f); + GL_TexEnv( 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_BLEND); + gl.glColor4f (1,1,1,1); + GL_TexEnv( 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_REPLACE ); + GL_SelectTexture(GL_TEXTURE1); + GL_TexEnv( 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(); + // auto cycle the world frame for texture animation + ent.frame = (int)(r_newrefdef.time*2); + currententity = ent; + + if (r_drawworld.value == 0) + return; + + if ( (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0 ) + return; + + currentmodel = r_worldmodel; + + Math3D.VectorCopy(r_newrefdef.vieworg, modelorg); + + 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_REPLACE ); + GL_SelectTexture( GL_TEXTURE1); + + if ( gl_lightmap.value != 0) + GL_TexEnv( GL_REPLACE ); + else + GL_TexEnv( 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_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + gl_lms.lightmap_buffer.rewind(); + 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_TEXTURE_2D, + 0, + 0, 0, + BLOCK_WIDTH, height, + GL_LIGHTMAP_FORMAT, + GL_UNSIGNED_BYTE, + gl_lms.lightmap_buffer ); + } + else + { + gl.glTexImage2D( GL_TEXTURE_2D, + 0, + gl_lms.internal_format, + BLOCK_WIDTH, BLOCK_HEIGHT, + 0, + GL_LIGHTMAP_FORMAT, + GL_UNSIGNED_BYTE, + gl_lms.lightmap_buffer ); + if ( ++gl_lms.current_lightmap_texture == MAX_LIGHTMAPS ) + Com.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 = Polygon.create(lnumverts); + + poly.next = fa.polys; + poly.flags = fa.flags; + fa.polys = poly; + + 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.x(i, vec[0]); + poly.y(i, vec[1]); + poly.z(i, vec[2]); + + //poly.verts[i][3] = s; + //poly.verts[i][4] = t; + poly.s1(i, s); + poly.t1(i, 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.s2(i, s); + poly.t2(i, t); + } + } + + /* + ======================== + GL_CreateSurfaceLightmap + ======================== + */ + void GL_CreateSurfaceLightmap(msurface_t surf) + { + int smax, tmax; + IntBuffer 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 ) ) + { + Com.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; + + int basep = (surf.light_t * BLOCK_WIDTH + surf.light_s);// * LIGHTMAP_BYTES; + base = gl_lms.lightmap_buffer; + base.position(basep); + + R_SetCacheState( surf ); + R_BuildLightMap(surf, base.slice(), BLOCK_WIDTH); + } + + lightstyle_t[] lightstyles; + private final IntBuffer dummy = Lib.newIntBuffer(128*128); + /* + ================== + GL_BeginBuildingLightmaps + + ================== + */ + void GL_BeginBuildingLightmaps(model_t m) + { + // static lightstyle_t lightstyles[MAX_LIGHTSTYLES]; + int i; + // 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_INTENSITY8; + } + else if ( format == 'L' ) + { + gl_lms.internal_format = 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_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + gl.glTexImage2D( GL_TEXTURE_2D, + 0, + gl_lms.internal_format, + BLOCK_WIDTH, BLOCK_HEIGHT, + 0, + GL_LIGHTMAP_FORMAT, + 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); +// +// } + +} diff --git a/src/jake2/render/basic/Warp.java b/src/jake2/render/basic/Warp.java new file mode 100644 index 0000000..16a1a0e --- /dev/null +++ b/src/jake2/render/basic/Warp.java @@ -0,0 +1,665 @@ +/* + * Warp.java + * Copyright (C) 2003 + * + * $Id: Warp.java,v 1.2 2006-11-21 00:50:46 cawe 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.basic; + +import jake2.Defines; +import jake2.Globals; +import jake2.qcommon.Com; +import jake2.render.*; +import jake2.util.Math3D; + +/** + * Warp + * + * @author cwei + */ +public abstract class Warp extends Model { + + // warpsin.h + public static final float[] SIN = { 0f, 0.19633f, 0.392541f, 0.588517f, + 0.784137f, 0.979285f, 1.17384f, 1.3677f, 1.56072f, 1.75281f, + 1.94384f, 2.1337f, 2.32228f, 2.50945f, 2.69512f, 2.87916f, + 3.06147f, 3.24193f, 3.42044f, 3.59689f, 3.77117f, 3.94319f, + 4.11282f, 4.27998f, 4.44456f, 4.60647f, 4.76559f, 4.92185f, + 5.07515f, 5.22538f, 5.37247f, 5.51632f, 5.65685f, 5.79398f, + 5.92761f, 6.05767f, 6.18408f, 6.30677f, 6.42566f, 6.54068f, + 6.65176f, 6.75883f, 6.86183f, 6.9607f, 7.05537f, 7.14579f, + 7.23191f, 7.31368f, 7.39104f, 7.46394f, 7.53235f, 7.59623f, + 7.65552f, 7.71021f, 7.76025f, 7.80562f, 7.84628f, 7.88222f, + 7.91341f, 7.93984f, 7.96148f, 7.97832f, 7.99036f, 7.99759f, 8f, + 7.99759f, 7.99036f, 7.97832f, 7.96148f, 7.93984f, 7.91341f, + 7.88222f, 7.84628f, 7.80562f, 7.76025f, 7.71021f, 7.65552f, + 7.59623f, 7.53235f, 7.46394f, 7.39104f, 7.31368f, 7.23191f, + 7.14579f, 7.05537f, 6.9607f, 6.86183f, 6.75883f, 6.65176f, + 6.54068f, 6.42566f, 6.30677f, 6.18408f, 6.05767f, 5.92761f, + 5.79398f, 5.65685f, 5.51632f, 5.37247f, 5.22538f, 5.07515f, + 4.92185f, 4.76559f, 4.60647f, 4.44456f, 4.27998f, 4.11282f, + 3.94319f, 3.77117f, 3.59689f, 3.42044f, 3.24193f, 3.06147f, + 2.87916f, 2.69512f, 2.50945f, 2.32228f, 2.1337f, 1.94384f, + 1.75281f, 1.56072f, 1.3677f, 1.17384f, 0.979285f, 0.784137f, + 0.588517f, 0.392541f, 0.19633f, 9.79717e-16f, -0.19633f, + -0.392541f, -0.588517f, -0.784137f, -0.979285f, -1.17384f, + -1.3677f, -1.56072f, -1.75281f, -1.94384f, -2.1337f, -2.32228f, + -2.50945f, -2.69512f, -2.87916f, -3.06147f, -3.24193f, -3.42044f, + -3.59689f, -3.77117f, -3.94319f, -4.11282f, -4.27998f, -4.44456f, + -4.60647f, -4.76559f, -4.92185f, -5.07515f, -5.22538f, -5.37247f, + -5.51632f, -5.65685f, -5.79398f, -5.92761f, -6.05767f, -6.18408f, + -6.30677f, -6.42566f, -6.54068f, -6.65176f, -6.75883f, -6.86183f, + -6.9607f, -7.05537f, -7.14579f, -7.23191f, -7.31368f, -7.39104f, + -7.46394f, -7.53235f, -7.59623f, -7.65552f, -7.71021f, -7.76025f, + -7.80562f, -7.84628f, -7.88222f, -7.91341f, -7.93984f, -7.96148f, + -7.97832f, -7.99036f, -7.99759f, -8f, -7.99759f, -7.99036f, + -7.97832f, -7.96148f, -7.93984f, -7.91341f, -7.88222f, -7.84628f, + -7.80562f, -7.76025f, -7.71021f, -7.65552f, -7.59623f, -7.53235f, + -7.46394f, -7.39104f, -7.31368f, -7.23191f, -7.14579f, -7.05537f, + -6.9607f, -6.86183f, -6.75883f, -6.65176f, -6.54068f, -6.42566f, + -6.30677f, -6.18408f, -6.05767f, -5.92761f, -5.79398f, -5.65685f, + -5.51632f, -5.37247f, -5.22538f, -5.07515f, -4.92185f, -4.76559f, + -4.60647f, -4.44456f, -4.27998f, -4.11282f, -3.94319f, -3.77117f, + -3.59689f, -3.42044f, -3.24193f, -3.06147f, -2.87916f, -2.69512f, + -2.50945f, -2.32228f, -2.1337f, -1.94384f, -1.75281f, -1.56072f, + -1.3677f, -1.17384f, -0.979285f, -0.784137f, -0.588517f, + -0.392541f, -0.19633f }; + + // gl_warp.c -- sky and water polygons + //extern model_t *loadmodel; // Model.java + + String skyname; + + float skyrotate; + + float[] skyaxis = { 0, 0, 0 }; + + image_t[] sky_images = new image_t[6]; + + msurface_t warpface; + + static final int SUBDIVIDE_SIZE = 64; + + void BoundPoly(int numverts, float[][] verts, float[] mins, float[] maxs) { + int i, j; + float[] v; + + mins[0] = mins[1] = mins[2] = 9999; + maxs[0] = maxs[1] = maxs[2] = -9999; + for (i = 0; i < numverts; i++) { + v = verts[i]; + for (j = 0; j < 3; j++) { + if (v[j] < mins[j]) + mins[j] = v[j]; + if (v[j] > maxs[j]) + maxs[j] = v[j]; + } + } + } + + void SubdividePolygon(int numverts, float[][] verts) { + int i, j, k; + float[] mins = { 0, 0, 0 }; + float[] maxs = { 0, 0, 0 }; + float m; + float[] v = { 0, 0, 0 }; + float[][] front = new float[64][3]; + float[][] back = new float[64][3]; + + int f, b; + float[] dist = new float[64]; + float frac; + float s, t; + float[] total = { 0, 0, 0 }; + float total_s, total_t; + + if (numverts > 60) + Com.Error(Defines.ERR_DROP, "numverts = " + numverts); + + BoundPoly(numverts, verts, mins, maxs); + + // x,y und z + for (i = 0; i < 3; i++) { + m = (mins[i] + maxs[i]) * 0.5f; + m = SUBDIVIDE_SIZE * (float) Math.floor(m / SUBDIVIDE_SIZE + 0.5f); + if (maxs[i] - m < 8) + continue; + if (m - mins[i] < 8) + continue; + + // cut it + for (j = 0; j < numverts; j++) { + dist[j] = verts[j][i] - m; + } + + // wrap cases + dist[j] = dist[0]; + + Math3D.VectorCopy(verts[0], verts[numverts]); + + f = b = 0; + for (j = 0; j < numverts; j++) { + v = verts[j]; + if (dist[j] >= 0) { + Math3D.VectorCopy(v, front[f]); + f++; + } + if (dist[j] <= 0) { + Math3D.VectorCopy(v, back[b]); + b++; + } + if (dist[j] == 0 || dist[j + 1] == 0) + continue; + + if ((dist[j] > 0) != (dist[j + 1] > 0)) { + // clip point + frac = dist[j] / (dist[j] - dist[j + 1]); + for (k = 0; k < 3; k++) + front[f][k] = back[b][k] = v[k] + frac + * (verts[j + 1][k] - v[k]); + + f++; + b++; + } + } + + SubdividePolygon(f, front); + SubdividePolygon(b, back); + return; + } + + // add a point in the center to help keep warp valid + + // wird im Konstruktor erschlagen + // poly = Hunk_Alloc (sizeof(glpoly_t) + ((numverts-4)+2) * + // VERTEXSIZE*sizeof(float)); + + // init polys + glpoly_t poly = Polygon.create(numverts + 2); + + poly.next = warpface.polys; + warpface.polys = poly; + Math3D.VectorClear(total); + total_s = 0; + total_t = 0; + for (i = 0; i < numverts; i++) { + poly.x(i + 1, verts[i][0]); + poly.y(i + 1, verts[i][1]); + poly.z(i + 1, verts[i][2]); + s = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[0]); + t = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[1]); + + total_s += s; + total_t += t; + Math3D.VectorAdd(total, verts[i], total); + + poly.s1(i + 1, s); + poly.t1(i + 1, t); + } + + float scale = 1.0f / numverts; + poly.x(0, total[0] * scale); + poly.y(0, total[1] * scale); + poly.z(0, total[2] * scale); + poly.s1(0, total_s * scale); + poly.t1(0, total_t * scale); + + poly.x(i + 1, poly.x(1)); + poly.y(i + 1, poly.y(1)); + poly.z(i + 1, poly.z(1)); + poly.s1(i + 1, poly.s1(1)); + poly.t1(i + 1, poly.t1(1)); + poly.s2(i + 1, poly.s2(1)); + poly.t2(i + 1, poly.t2(1)); + } + + /* + * GL_SubdivideSurface + * + * Breaks a polygon up along axial 64 unit boundaries so that turbulent and + * sky warps can be done reasonably. + */ + float[][] tmpVerts = new float[64][3]; + + void GL_SubdivideSurface(msurface_t fa) { + float[][] verts = tmpVerts; + float[] vec; + warpface = fa; + // + // convert edges back to a normal polygon + // + int numverts = 0; + for (int i = 0; i < fa.numedges; i++) { + int lindex = loadmodel.surfedges[fa.firstedge + i]; + + if (lindex > 0) + vec = loadmodel.vertexes[loadmodel.edges[lindex].v[0]].position; + else + vec = loadmodel.vertexes[loadmodel.edges[-lindex].v[1]].position; + Math3D.VectorCopy(vec, verts[numverts]); + numverts++; + } + SubdividePolygon(numverts, verts); + } + + // ========================================================= + + //// speed up sin calculations - Ed + // float r_turbsin[] = + // { + // #include "warpsin.h" + // }; + static final float TURBSCALE = (float) (256.0f / (2 * Math.PI)); + + /* + * ============= EmitWaterPolys + * + * Does a water warp on the pre-fragmented glpoly_t chain ============= + */ + void EmitWaterPolys(msurface_t fa) { + glpoly_t p, bp; + int i; + float s = 0; + float t = 0; + float os, ot; + float scroll; + float rdt = r_newrefdef.time; + + if ((fa.texinfo.flags & Defines.SURF_FLOWING) != 0) + scroll = -64 + * ((r_newrefdef.time * 0.5f) - (int) (r_newrefdef.time * 0.5f)); + else + scroll = 0; + for (bp = fa.polys; bp != null; bp = bp.next) { + p = bp; + + gl.glBegin(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); + + gl.glTexCoord2f(s, t); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + gl.glEnd(); + } + } + + // =================================================================== + + float[][] skyclip = { { 1, 1, 0 }, { 1, -1, 0 }, { 0, -1, 1 }, { 0, 1, 1 }, + { 1, 0, 1 }, { -1, 0, 1 } }; + + int c_sky; + + // 1 = s, 2 = t, 3 = 2048 + int[][] st_to_vec = { { 3, -1, 2 }, { -3, 1, 2 }, + + { 1, 3, 2 }, { -1, -3, 2 }, + + { -2, -1, 3 }, // 0 degrees yaw, look straight up + { 2, -1, -3 } // look straight down + + }; + + int[][] vec_to_st = { { -2, 3, 1 }, { 2, 3, -1 }, + + { 1, 3, 2 }, { -1, 3, -2 }, + + { -2, -1, 3 }, { -2, 1, -3 } + + }; + + float[][] skymins = new float[2][6]; + + float[][] skymaxs = new float[2][6]; + + float sky_min, sky_max; + + void DrawSkyPolygon(int nump, float[][] vecs) { + int i, j; + float[] v = { 0, 0, 0 }; + float[] av = { 0, 0, 0 }; + float s, t, dv; + int axis; + float[] vp; + + c_sky++; + // decide which face it maps to + Math3D.VectorCopy(Globals.vec3_origin, v); + for (i = 0; i < nump; i++) { + Math3D.VectorAdd(vecs[i], v, v); + } + av[0] = Math.abs(v[0]); + av[1] = Math.abs(v[1]); + av[2] = Math.abs(v[2]); + if (av[0] > av[1] && av[0] > av[2]) { + if (v[0] < 0) + axis = 1; + else + axis = 0; + } else if (av[1] > av[2] && av[1] > av[0]) { + if (v[1] < 0) + axis = 3; + else + axis = 2; + } else { + if (v[2] < 0) + axis = 5; + else + axis = 4; + } + + // project new texture coords + for (i = 0; i < nump; i++) { + j = vec_to_st[axis][2]; + if (j > 0) + dv = vecs[i][j - 1]; + else + dv = -vecs[i][-j - 1]; + if (dv < 0.001f) + continue; // don't divide by zero + j = vec_to_st[axis][0]; + if (j < 0) + s = -vecs[i][-j - 1] / dv; + else + s = vecs[i][j - 1] / dv; + j = vec_to_st[axis][1]; + if (j < 0) + t = -vecs[i][-j - 1] / dv; + else + t = vecs[i][j - 1] / dv; + + if (s < skymins[0][axis]) + skymins[0][axis] = s; + if (t < skymins[1][axis]) + skymins[1][axis] = t; + if (s > skymaxs[0][axis]) + skymaxs[0][axis] = s; + if (t > skymaxs[1][axis]) + skymaxs[1][axis] = t; + } + } + + static final float ON_EPSILON = 0.1f; // point on plane side epsilon + + static final int MAX_CLIP_VERTS = 64; + + static final int SIDE_BACK = 1; + + static final int SIDE_FRONT = 0; + + static final int SIDE_ON = 2; + + float[] dists = new float[MAX_CLIP_VERTS]; + + int[] sides = new int[MAX_CLIP_VERTS]; + + float[][][][] newv = new float[6][2][MAX_CLIP_VERTS][3]; + + void ClipSkyPolygon(int nump, float[][] vecs, int stage) { + float[] norm; + float[] v; + boolean front, back; + float d, e; + int[] newc = { 0, 0 }; + int i, j; + + if (nump > MAX_CLIP_VERTS - 2) + Com.Error(Defines.ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS"); + if (stage == 6) { // fully clipped, so draw it + DrawSkyPolygon(nump, vecs); + return; + } + + front = back = false; + norm = skyclip[stage]; + for (i = 0; i < nump; i++) { + d = Math3D.DotProduct(vecs[i], norm); + if (d > ON_EPSILON) { + front = true; + sides[i] = SIDE_FRONT; + } else if (d < -ON_EPSILON) { + back = true; + sides[i] = SIDE_BACK; + } else + sides[i] = SIDE_ON; + dists[i] = d; + } + + if (!front || !back) { // not clipped + ClipSkyPolygon(nump, vecs, stage + 1); + return; + } + + // clip it + sides[i] = sides[0]; + dists[i] = dists[0]; + Math3D.VectorCopy(vecs[0], vecs[i]); + newc[0] = newc[1] = 0; + + for (i = 0; i < nump; i++) { + v = vecs[i]; + switch (sides[i]) { + case SIDE_FRONT: + Math3D.VectorCopy(v, newv[stage][0][newc[0]]); + newc[0]++; + break; + case SIDE_BACK: + Math3D.VectorCopy(v, newv[stage][1][newc[1]]); + newc[1]++; + break; + case SIDE_ON: + Math3D.VectorCopy(v, newv[stage][0][newc[0]]); + newc[0]++; + Math3D.VectorCopy(v, newv[stage][1][newc[1]]); + newc[1]++; + break; + } + + if (sides[i] == SIDE_ON || sides[i + 1] == SIDE_ON + || sides[i + 1] == sides[i]) + continue; + + d = dists[i] / (dists[i] - dists[i + 1]); + for (j = 0; j < 3; j++) { + e = v[j] + d * (vecs[i + 1][j] - v[j]); + newv[stage][0][newc[0]][j] = e; + newv[stage][1][newc[1]][j] = e; + } + newc[0]++; + newc[1]++; + } + + // continue + ClipSkyPolygon(newc[0], newv[stage][0], stage + 1); + ClipSkyPolygon(newc[1], newv[stage][1], stage + 1); + } + + float[][] verts = new float[MAX_CLIP_VERTS][3]; + + /* + * R_AddSkySurface + */ + void R_AddSkySurface(msurface_t fa) { + // calculate vertex values for sky box + for (glpoly_t p = fa.polys; p != null; p = p.next) { + for (int i = 0; i < p.numverts; i++) { + verts[i][0] = p.x(i) - r_origin[0]; + verts[i][1] = p.y(i) - r_origin[1]; + verts[i][2] = p.z(i) - r_origin[2]; + } + ClipSkyPolygon(p.numverts, verts, 0); + } + } + + /* + * ============== R_ClearSkyBox ============== + */ + void R_ClearSkyBox() { + int i; + + for (i = 0; i < 6; i++) { + skymins[0][i] = skymins[1][i] = 9999; + skymaxs[0][i] = skymaxs[1][i] = -9999; + } + } + + void MakeSkyVec(float s, float t, int axis) { + float[] v = { 0, 0, 0 }; + float[] b = { 0, 0, 0 }; + int j, k; + + b[0] = s * 2300; + b[1] = t * 2300; + b[2] = 2300; + + for (j = 0; j < 3; j++) { + k = st_to_vec[axis][j]; + if (k < 0) + v[j] = -b[-k - 1]; + else + v[j] = b[k - 1]; + } + + // avoid bilerp seam + s = (s + 1) * 0.5f; + t = (t + 1) * 0.5f; + + if (s < sky_min) + s = sky_min; + else if (s > sky_max) + s = sky_max; + if (t < sky_min) + t = sky_min; + else if (t > sky_max) + t = sky_max; + + t = 1.0f - t; + gl.glTexCoord2f(s, t); + gl.glVertex3f(v[0], v[1], v[2]); + } + + /* + * ============== R_DrawSkyBox ============== + */ + int[] skytexorder = { 0, 2, 1, 3, 4, 5 }; + + 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 + } + + gl.glPushMatrix(); + gl.glTranslatef(r_origin[0], r_origin[1], r_origin[2]); + gl.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); + + gl.glBegin(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); + gl.glEnd(); + } + gl.glPopMatrix(); + } + + /* + * ============ R_SetSky ============ + */ + // 3dstudio environment map names + String[] suf = { "rt", "bk", "lf", "ft", "up", "dn" }; + + public void R_SetSky(String name, float rotate, float[] axis) { + assert (axis.length == 3) : "vec3_t bug"; + int i; + String pathname; + + // strncpy (skyname, name, sizeof(skyname)-1); + skyname = name; + + skyrotate = rotate; + Math3D.VectorCopy(axis, skyaxis); + + for (i = 0; i < 6; i++) { + // chop down rotating skies for less memory + if (gl_skymip.value != 0 || skyrotate != 0) + gl_picmip.value++; + + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0) { + // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.pcx", + // skyname, suf[i]); + pathname = "env/" + skyname + suf[i] + ".pcx"; + } else { + // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.tga", + // skyname, suf[i]); + pathname = "env/" + skyname + suf[i] + ".tga"; + } + + sky_images[i] = GL_FindImage(pathname, it_sky); + + if (sky_images[i] == null) + sky_images[i] = r_notexture; + + if (gl_skymip.value != 0 || skyrotate != 0) { // take less memory + gl_picmip.value--; + sky_min = 1.0f / 256; + sky_max = 255.0f / 256; + } else { + sky_min = 1.0f / 512; + sky_max = 511.0f / 512; + } + } + } + +}
\ No newline at end of file diff --git a/src/jake2/render/common/Base.java b/src/jake2/render/common/Base.java deleted file mode 100644 index a9e09c4..0000000 --- a/src/jake2/render/common/Base.java +++ /dev/null @@ -1,154 +0,0 @@ -/* -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. - -*/ - -// Created on 19.08.2006 by RST. -// $Id: Base.java,v 1.2 2006-10-31 14:00:23 salomo Exp $ - -package jake2.render.common; - -import java.nio.*; - -public class Base { - - public static GenericGL ggl; - - // to be initialized - protected int GL_TEXTURE0 = -1; - protected int GL_TEXTURE1 = -1; - protected int GL_COLOR_INDEX8_EXT = ggl.GL_COLOR_INDEX; - public static final String REF_VERSION = "GL 0.01"; - - // up / down - public static final int PITCH = 0; - // left / right - public static final int YAW = 1; - // fall over - public static final int ROLL = 2; - - // enum imagetype_t - public static final int it_skin = 0; - public static final int it_sprite = 1; - public static final int it_wall = 2; - public static final int it_pic = 3; - public static final int it_sky = 4; - // enum modtype_t - public static final int mod_bad = 0; - public static final int mod_brush = 1; - public static final int mod_sprite = 2; - public static final int mod_alias = 3; - public static final int TEXNUM_LIGHTMAPS = 1024; - public static final int TEXNUM_SCRAPS = 1152; - public static final int TEXNUM_IMAGES = 1153; - public static final int MAX_GLTEXTURES = 1024; - public static final int MAX_LBM_HEIGHT = 480; - public static final float BACKFACE_EPSILON = 0.01f; - /* - * * GL config stuff - */ - public static final int GL_RENDERER_VOODOO = 0x00000001; - public static final int GL_RENDERER_VOODOO2 = 0x00000002; - public static final int GL_RENDERER_VOODOO_RUSH = 0x00000004; - public static final int GL_RENDERER_BANSHEE = 0x00000008; - public static final int GL_RENDERER_3DFX = 0x0000000F; - public static final int GL_RENDERER_PCX1 = 0x00000010; - public static final int GL_RENDERER_PCX2 = 0x00000020; - public static final int GL_RENDERER_PMX = 0x00000040; - public static final int GL_RENDERER_POWERVR = 0x00000070; - public static final int GL_RENDERER_PERMEDIA2 = 0x00000100; - public static final int GL_RENDERER_GLINT_MX = 0x00000200; - public static final int GL_RENDERER_GLINT_TX = 0x00000400; - public static final int GL_RENDERER_3DLABS_MISC = 0x00000800; - public static final int GL_RENDERER_3DLABS = 0x00000F00; - public static final int GL_RENDERER_REALIZM = 0x00001000; - public static final int GL_RENDERER_REALIZM2 = 0x00002000; - public static final int GL_RENDERER_INTERGRAPH = 0x00003000; - public static final int GL_RENDERER_3DPRO = 0x00004000; - public static final int GL_RENDERER_REAL3D = 0x00008000; - public static final int GL_RENDERER_RIVA128 = 0x00010000; - public static final int GL_RENDERER_DYPIC = 0x00020000; - public static final int GL_RENDERER_V1000 = 0x00040000; - public static final int GL_RENDERER_V2100 = 0x00080000; - public static final int GL_RENDERER_V2200 = 0x00100000; - public static final int GL_RENDERER_RENDITION = 0x001C0000; - public static final int GL_RENDERER_O2 = 0x00100000; - public static final int GL_RENDERER_IMPACT = 0x00200000; - public static final int GL_RENDERER_RE = 0x00400000; - public static final int GL_RENDERER_IR = 0x00800000; - public static final int GL_RENDERER_SGI = 0x00F00000; - public static final int GL_RENDERER_MCD = 0x01000000; - public static final int GL_RENDERER_OTHER = 0x80000000; - - // to unify BufferUtils. - - public static final int SIZEOF_BYTE = 1; - public static final int SIZEOF_SHORT = 2; - public static final int SIZEOF_INT = 4; - public static final int SIZEOF_FLOAT = 4; - public static final int SIZEOF_LONG = 8; - public static final int SIZEOF_DOUBLE = 8; - - // ---------------------------------------------------------------------- - // Allocation routines - // - - /** - * Allocates a new direct ByteBuffer with the specified number of elements. - * The returned buffer will have its byte order set to the host platform's - * native byte order. - */ - public static ByteBuffer newByteBuffer(int numElements) { - ByteBuffer bb = ByteBuffer.allocateDirect(numElements); - bb.order(ByteOrder.nativeOrder()); - return bb; - } - - /** Allocates a new direct DoubleBuffer with the specified number of - elements. The returned buffer will have its byte order set to - the host platform's native byte order. */ - public static DoubleBuffer newDoubleBuffer(int numElements) { - ByteBuffer bb = newByteBuffer(numElements * SIZEOF_DOUBLE); - return bb.asDoubleBuffer(); - } - - /** Allocates a new direct FloatBuffer with the specified number of - elements. The returned buffer will have its byte order set to - the host platform's native byte order. */ - public static FloatBuffer newFloatBuffer(int numElements) { - ByteBuffer bb = newByteBuffer(numElements * SIZEOF_FLOAT); - return bb.asFloatBuffer(); - } - - /** Allocates a new direct IntBuffer with the specified number of - elements. The returned buffer will have its byte order set to - the host platform's native byte order. */ - public static IntBuffer newIntBuffer(int numElements) { - ByteBuffer bb = newByteBuffer(numElements * SIZEOF_INT); - return bb.asIntBuffer(); - } - - /** Allocates a new direct LongBuffer with the specified number of - elements. The returned buffer will have its byte order set to - the host platform's native byte order. */ - public static LongBuffer newLongBuffer(int numElements) { - ByteBuffer bb = newByteBuffer(numElements * SIZEOF_LONG); - return bb.asLongBuffer(); - } - -} diff --git a/src/jake2/render/common/Draw.java b/src/jake2/render/common/Draw.java deleted file mode 100644 index b3cb1f4..0000000 --- a/src/jake2/render/common/Draw.java +++ /dev/null @@ -1,398 +0,0 @@ -/* - * Draw.java - * Copyright (C) 2003 - * - * $Id: Draw.java,v 1.1 2006-10-31 13:06:32 salomo 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.common; - -import jake2.Defines; -import jake2.client.VID; -import jake2.qcommon.Com; -import jake2.render.image_t; -import jake2.util.Lib; - -import java.awt.Dimension; -import java.nio.ByteBuffer; -import java.nio.IntBuffer; - -/** - * Draw - * (gl_draw.c) - * - * @author cwei - */ -public abstract class Draw extends Model { - - /* - =============== - Draw_InitLocal - =============== - */ - protected void Draw_InitLocal() { - // load console characters (don't bilerp characters) - draw_chars = GL_FindImage("pics/conchars.pcx", Base.it_pic); - GL_Bind(draw_chars.texnum); - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, ggl.GL_NEAREST); - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, ggl.GL_NEAREST); - } - - /* - ================ - Draw_Char - - Draws one 8*8 graphics character with 0 being transparent. - It can be clipped to the top of the screen to allow the console to be - smoothly scrolled off. - ================ - */ - protected void Draw_Char(int x, int y, int num) { - - num &= 255; - - if ( (num&127) == 32 ) return; // space - - if (y <= -8) return; // totally off screen - - int row = num >> 4; - int col = num & 15; - - float frow = row * 0.0625f; - float fcol = col * 0.0625f; - float size = 0.0625f; - - GL_Bind(draw_chars.texnum); - - ggl.glBegin(ggl.GL_QUADS); - ggl.glTexCoord2f(fcol, frow); - ggl.glVertex2f(x, y); - ggl.glTexCoord2f(fcol + size, frow); - ggl.glVertex2f(x + 8, y); - ggl.glTexCoord2f(fcol + size, frow + size); - ggl.glVertex2f(x + 8, y + 8); - ggl.glTexCoord2f(fcol, frow + size); - ggl.glVertex2f(x, y + 8); - ggl.glEnd(); - } - - - /* - ============= - Draw_FindPic - ============= - */ - protected image_t Draw_FindPic(String name) { - image_t image = null; - String fullname; - - if (!name.startsWith("/") && !name.startsWith("\\")) - { - fullname = "pics/" + name + ".pcx"; - image = GL_FindImage(fullname, Base.it_pic); - } else { - image = GL_FindImage(name.substring(1), Base.it_pic); - } - return image; - } - - - /* - ============= - Draw_GetPicSize - ============= - */ - protected void Draw_GetPicSize(Dimension dim, String pic) { - image_t image = Draw_FindPic(pic); - dim.width = (image != null) ? image.width : -1; - dim.height = (image != null) ? image.height : -1; - } - - /* - ============= - Draw_StretchPic - ============= - */ - protected void Draw_StretchPic(int x, int y, int w, int h, String pic) { - - image_t image; - - image = Draw_FindPic(pic); - if (image == null) - { - VID.Printf (Defines.PRINT_ALL, "Can't find pic: " + pic +'\n'); - return; - } - - if (scrap_dirty) - Scrap_Upload(); - - if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - && !image.has_alpha) - ggl.glDisable(ggl.GL_ALPHA_TEST); - - GL_Bind(image.texnum); - ggl.glBegin(ggl.GL_QUADS); - ggl.glTexCoord2f(image.sl, image.tl); - ggl.glVertex2f(x, y); - ggl.glTexCoord2f(image.sh, image.tl); - ggl.glVertex2f(x + w, y); - ggl.glTexCoord2f(image.sh, image.th); - ggl.glVertex2f(x + w, y + h); - ggl.glTexCoord2f(image.sl, image.th); - ggl.glVertex2f(x, y + h); - ggl.glEnd(); - - if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - && !image.has_alpha) - ggl.glEnable(ggl.GL_ALPHA_TEST); - } - - - /* - ============= - Draw_Pic - ============= - */ - protected void Draw_Pic(int x, int y, String pic) - { - image_t image; - - image = Draw_FindPic(pic); - if (image == null) - { - VID.Printf(Defines.PRINT_ALL, "Can't find pic: " +pic + '\n'); - return; - } - if (scrap_dirty) - Scrap_Upload(); - - if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - && !image.has_alpha) - ggl.glDisable(ggl.GL_ALPHA_TEST); - - GL_Bind(image.texnum); - - ggl.glBegin(ggl.GL_QUADS); - ggl.glTexCoord2f(image.sl, image.tl); - ggl.glVertex2f(x, y); - ggl.glTexCoord2f(image.sh, image.tl); - ggl.glVertex2f(x + image.width, y); - ggl.glTexCoord2f(image.sh, image.th); - ggl.glVertex2f(x + image.width, y + image.height); - ggl.glTexCoord2f(image.sl, image.th); - ggl.glVertex2f(x, y + image.height); - ggl.glEnd(); - - if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - && !image.has_alpha) - ggl.glEnable(ggl.GL_ALPHA_TEST); - } - - /* - ============= - Draw_TileClear - - This repeats a 64*64 tile graphic to fill the screen around a sized down - refresh window. - ============= - */ - protected void Draw_TileClear(int x, int y, int w, int h, String pic) { - image_t image; - - image = Draw_FindPic(pic); - if (image == null) - { - VID.Printf(Defines.PRINT_ALL, "Can't find pic: " + pic + '\n'); - return; - } - - if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - && !image.has_alpha) - ggl.glDisable(ggl.GL_ALPHA_TEST); - - GL_Bind(image.texnum); - ggl.glBegin(ggl.GL_QUADS); - ggl.glTexCoord2f(x / 64.0f, y / 64.0f); - ggl.glVertex2f(x, y); - ggl.glTexCoord2f((x + w) / 64.0f, y / 64.0f); - ggl.glVertex2f(x + w, y); - ggl.glTexCoord2f((x + w) / 64.0f, (y + h) / 64.0f); - ggl.glVertex2f(x + w, y + h); - ggl.glTexCoord2f(x / 64.0f, (y + h) / 64.0f); - ggl.glVertex2f(x, y + h); - ggl.glEnd(); - - if (((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - && !image.has_alpha) - ggl.glEnable(ggl.GL_ALPHA_TEST); - } - - - /* - ============= - Draw_Fill - - Fills a box of pixels with a single color - ============= - */ - 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"); - - ggl.glDisable(ggl.GL_TEXTURE_2D); - - int color = d_8to24table[colorIndex]; - - ggl.glColor3ub((byte) ((color >> 0) & 0xff), // r - (byte) ((color >> 8) & 0xff), // g - (byte) ((color >> 16) & 0xff) // b - ); - - ggl.glBegin(ggl.GL_QUADS); - - ggl.glVertex2f(x, y); - ggl.glVertex2f(x + w, y); - ggl.glVertex2f(x + w, y + h); - ggl.glVertex2f(x, y + h); - - ggl.glEnd(); - ggl.glColor3f(1, 1, 1); - ggl.glEnable(ggl.GL_TEXTURE_2D); - } - - // ============================================================================= - - /* - ================ - Draw_FadeScreen - ================ - */ - protected void Draw_FadeScreen() { - ggl.glEnable(ggl.GL_BLEND); - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glColor4f(0, 0, 0, 0.8f); - ggl.glBegin(ggl.GL_QUADS); - - ggl.glVertex2f(0, 0); - ggl.glVertex2f(vid.width, 0); - ggl.glVertex2f(vid.width, vid.height); - ggl.glVertex2f(0, vid.height); - - ggl.glEnd(); - ggl.glColor4f(1, 1, 1, 1); - ggl.glEnable(ggl.GL_TEXTURE_2D); - ggl.glDisable(ggl.GL_BLEND); - } - - // ==================================================================== - - // allocate a 256 * 256 texture buffer - private ByteBuffer image8 = Lib.newByteBuffer(256 * 256 * Defines.SIZE_OF_INT); - // share the buffer - private IntBuffer image32 = image8.asIntBuffer(); - - /* - ============= - Draw_StretchRaw - ============= - */ - 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; - 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 destIndex = 0; - image32.clear(); - - 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; - } - } - ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, gl_tex_solid_format, 256, 256, 0, ggl.GL_RGBA, ggl.GL_UNSIGNED_BYTE, image32); - } else { - int destIndex = 0; - image8.clear(); - - 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; - } - } - - ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, 256, 256, 0, ggl.GL_COLOR_INDEX, ggl.GL_UNSIGNED_BYTE, - image8); - } - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, ggl.GL_LINEAR); - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, ggl.GL_LINEAR); - - - if ((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - ggl.glDisable(ggl.GL_ALPHA_TEST); - - ggl.glBegin(ggl.GL_QUADS); - ggl.glTexCoord2f(0, 0); - ggl.glVertex2f(x, y); - ggl.glTexCoord2f(1, 0); - ggl.glVertex2f(x + w, y); - ggl.glTexCoord2f(1, t); - ggl.glVertex2f(x + w, y + h); - ggl.glTexCoord2f(0, t); - ggl.glVertex2f(x, y + h); - ggl.glEnd(); - - if ((gl_config.renderer == Base.GL_RENDERER_MCD) || ((gl_config.renderer & Base.GL_RENDERER_RENDITION) != 0)) - ggl.glEnable(ggl.GL_ALPHA_TEST); - } -} diff --git a/src/jake2/render/common/GenericGL.java b/src/jake2/render/common/GenericGL.java deleted file mode 100644 index 2d75f17..0000000 --- a/src/jake2/render/common/GenericGL.java +++ /dev/null @@ -1,619 +0,0 @@ -/* -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. - -*/ - -// Created on 28.10.2006 by RST. - -// $Id: GenericGL.java,v 1.1 2006-10-31 13:06:32 salomo Exp $ - -package jake2.render.common; - -import java.nio.*; - -/** - * This is a class for wrapping lwjgl and jogl GL methods. - * It is not known if it performs well, but jit should know what we'Re doing. - */ -public interface GenericGL { - - public static final int GL_2_BYTES = 5127; - public static final int GL_2D = 1536; - public static final int GL_3_BYTES = 5128; - public static final int GL_3D = 1537; - public static final int GL_3D_COLOR = 1538; - public static final int GL_3D_COLOR_TEXTURE = 1539; - public static final int GL_4_BYTES = 5129; - public static final int GL_4D_COLOR_TEXTURE = 1540; - public static final int GL_ACCUM = 256; - public static final int GL_ACCUM_ALPHA_BITS = 3419; - public static final int GL_ACCUM_BLUE_BITS = 3418; - public static final int GL_ACCUM_BUFFER_BIT = 512; - public static final int GL_ACCUM_CLEAR_VALUE = 2944; - public static final int GL_ACCUM_GREEN_BITS = 3417; - public static final int GL_ACCUM_RED_BITS = 3416; - public static final int GL_ADD = 260; - public static final int GL_ALL_ATTRIB_BITS = 0xfffff; - public static final int GL_ALL_CLIENT_ATTRIB_BITS = -1; - public static final int GL_ALPHA = 6406; - public static final int GL_ALPHA_BIAS = 3357; - public static final int GL_ALPHA_BITS = 3413; - public static final int GL_ALPHA_SCALE = 3356; - public static final int GL_ALPHA_TEST = 3008; - public static final int GL_ALPHA_TEST_FUNC = 3009; - public static final int GL_ALPHA_TEST_REF = 3010; - public static final int GL_ALPHA12 = 32829; - public static final int GL_ALPHA16 = 32830; - public static final int GL_ALPHA4 = 32827; - public static final int GL_ALPHA8 = 32828; - public static final int GL_ALWAYS = 519; - public static final int GL_AMBIENT = 4608; - public static final int GL_AMBIENT_AND_DIFFUSE = 5634; - public static final int GL_AND = 5377; - public static final int GL_AND_INVERTED = 5380; - public static final int GL_AND_REVERSE = 5378; - public static final int GL_ATTRIB_STACK_DEPTH = 2992; - public static final int GL_AUTO_NORMAL = 3456; - public static final int GL_AUX_BUFFERS = 3072; - public static final int GL_AUX0 = 1033; - public static final int GL_AUX1 = 1034; - public static final int GL_AUX2 = 1035; - public static final int GL_AUX3 = 1036; - public static final int GL_BACK = 1029; - public static final int GL_BACK_LEFT = 1026; - public static final int GL_BACK_RIGHT = 1027; - public static final int GL_BITMAP = 6656; - public static final int GL_BITMAP_TOKEN = 1796; - public static final int GL_BLEND = 3042; - public static final int GL_BLEND_DST = 3040; - public static final int GL_BLEND_SRC = 3041; - public static final int GL_BLUE = 6405; - public static final int GL_BLUE_BIAS = 3355; - public static final int GL_BLUE_BITS = 3412; - public static final int GL_BLUE_SCALE = 3354; - public static final int GL_BYTE = 5120; - public static final int GL_C3F_V3F = 10788; - public static final int GL_C4F_N3F_V3F = 10790; - public static final int GL_C4UB_V2F = 10786; - public static final int GL_C4UB_V3F = 10787; - public static final int GL_CCW = 2305; - public static final int GL_CLAMP = 10496; - public static final int GL_CLEAR = 5376; - public static final int GL_CLIENT_ATTRIB_STACK_DEPTH = 2993; - public static final int GL_CLIENT_PIXEL_STORE_BIT = 1; - public static final int GL_CLIENT_VERTEX_ARRAY_BIT = 2; - public static final int GL_CLIP_PLANE0 = 12288; - public static final int GL_CLIP_PLANE1 = 12289; - public static final int GL_CLIP_PLANE2 = 12290; - public static final int GL_CLIP_PLANE3 = 12291; - public static final int GL_CLIP_PLANE4 = 12292; - public static final int GL_CLIP_PLANE5 = 12293; - public static final int GL_COEFF = 2560; - public static final int GL_COLOR = 6144; - public static final int GL_COLOR_ARRAY = 32886; - public static final int GL_COLOR_ARRAY_POINTER = 32912; - public static final int GL_COLOR_ARRAY_SIZE = 32897; - public static final int GL_COLOR_ARRAY_STRIDE = 32899; - public static final int GL_COLOR_ARRAY_TYPE = 32898; - public static final int GL_COLOR_BUFFER_BIT = 16384; - public static final int GL_COLOR_CLEAR_VALUE = 3106; - public static final int GL_COLOR_INDEX = 6400; - public static final int GL_COLOR_INDEXES = 5635; - public static final int GL_COLOR_LOGIC_OP = 3058; - public static final int GL_COLOR_MATERIAL = 2903; - public static final int GL_COLOR_MATERIAL_FACE = 2901; - public static final int GL_COLOR_MATERIAL_PARAMETER = 2902; - public static final int GL_COLOR_WRITEMASK = 3107; - public static final int GL_COMPILE = 4864; - public static final int GL_COMPILE_AND_EXECUTE = 4865; - public static final int GL_CONSTANT_ALPHA = 32771; - public static final int GL_CONSTANT_ATTENUATION = 4615; - public static final int GL_CONSTANT_COLOR = 32769; - public static final int GL_COPY = 5379; - public static final int GL_COPY_INVERTED = 5388; - public static final int GL_COPY_PIXEL_TOKEN = 1798; - public static final int GL_CULL_FACE = 2884; - public static final int GL_CULL_FACE_MODE = 2885; - public static final int GL_CURRENT_BIT = 1; - public static final int GL_CURRENT_COLOR = 2816; - public static final int GL_CURRENT_INDEX = 2817; - public static final int GL_CURRENT_NORMAL = 2818; - public static final int GL_CURRENT_RASTER_COLOR = 2820; - public static final int GL_CURRENT_RASTER_DISTANCE = 2825; - public static final int GL_CURRENT_RASTER_INDEX = 2821; - public static final int GL_CURRENT_RASTER_POSITION = 2823; - public static final int GL_CURRENT_RASTER_POSITION_VALID = 2824; - public static final int GL_CURRENT_RASTER_TEXTURE_COORDS = 2822; - public static final int GL_CURRENT_TEXTURE_COORDS = 2819; - public static final int GL_CW = 2304; - public static final int GL_DECAL = 8449; - public static final int GL_DECR = 7683; - public static final int GL_DEPTH = 6145; - public static final int GL_DEPTH_BIAS = 3359; - public static final int GL_DEPTH_BITS = 3414; - public static final int GL_DEPTH_BUFFER_BIT = 256; - public static final int GL_DEPTH_CLEAR_VALUE = 2931; - public static final int GL_DEPTH_COMPONENT = 6402; - public static final int GL_DEPTH_FUNC = 2932; - public static final int GL_DEPTH_RANGE = 2928; - public static final int GL_DEPTH_SCALE = 3358; - public static final int GL_DEPTH_TEST = 2929; - public static final int GL_DEPTH_WRITEMASK = 2930; - public static final int GL_DIFFUSE = 4609; - public static final int GL_DITHER = 3024; - public static final int GL_DOMAIN = 2562; - public static final int GL_DONT_CARE = 4352; - public static final int GL_DOUBLE = 5130; - public static final int GL_DOUBLEBUFFER = 3122; - public static final int GL_DRAW_BUFFER = 3073; - public static final int GL_DRAW_PIXEL_TOKEN = 1797; - public static final int GL_DST_ALPHA = 772; - public static final int GL_DST_COLOR = 774; - public static final int GL_EDGE_FLAG = 2883; - public static final int GL_EDGE_FLAG_ARRAY = 32889; - public static final int GL_EDGE_FLAG_ARRAY_POINTER = 32915; - public static final int GL_EDGE_FLAG_ARRAY_STRIDE = 32908; - public static final int GL_EMISSION = 5632; - public static final int GL_ENABLE_BIT = 8192; - public static final int GL_EQUAL = 514; - public static final int GL_EQUIV = 5385; - public static final int GL_EVAL_BIT = 0x10000; - public static final int GL_EXP = 2048; - public static final int GL_EXP2 = 2049; - public static final int GL_EXTENSIONS = 7939; - public static final int GL_EYE_LINEAR = 9216; - public static final int GL_EYE_PLANE = 9474; - public static final int GL_FALSE = 0; - public static final int GL_FASTEST = 4353; - public static final int GL_FEEDBACK = 7169; - public static final int GL_FEEDBACK_BUFFER_POINTER = 3568; - public static final int GL_FEEDBACK_BUFFER_SIZE = 3569; - public static final int GL_FEEDBACK_BUFFER_TYPE = 3570; - public static final int GL_FILL = 6914; - public static final int GL_FLAT = 7424; - public static final int GL_FLOAT = 5126; - public static final int GL_FOG = 2912; - public static final int GL_FOG_BIT = 128; - public static final int GL_FOG_COLOR = 2918; - public static final int GL_FOG_DENSITY = 2914; - public static final int GL_FOG_END = 2916; - public static final int GL_FOG_HINT = 3156; - public static final int GL_FOG_INDEX = 2913; - public static final int GL_FOG_MODE = 2917; - public static final int GL_FOG_START = 2915; - public static final int GL_FRONT = 1028; - public static final int GL_FRONT_AND_BACK = 1032; - public static final int GL_FRONT_FACE = 2886; - public static final int GL_FRONT_LEFT = 1024; - public static final int GL_FRONT_RIGHT = 1025; - public static final int GL_GEQUAL = 518; - public static final int GL_GREATER = 516; - public static final int GL_GREEN = 6404; - public static final int GL_GREEN_BIAS = 3353; - public static final int GL_GREEN_BITS = 3411; - public static final int GL_GREEN_SCALE = 3352; - public static final int GL_HINT_BIT = 32768; - public static final int GL_INCR = 7682; - public static final int GL_INDEX_ARRAY = 32887; - public static final int GL_INDEX_ARRAY_POINTER = 32913; - public static final int GL_INDEX_ARRAY_STRIDE = 32902; - public static final int GL_INDEX_ARRAY_TYPE = 32901; - public static final int GL_INDEX_BITS = 3409; - public static final int GL_INDEX_CLEAR_VALUE = 3104; - public static final int GL_INDEX_LOGIC_OP = 3057; - public static final int GL_INDEX_MODE = 3120; - public static final int GL_INDEX_OFFSET = 3347; - public static final int GL_INDEX_SHIFT = 3346; - public static final int GL_INDEX_WRITEMASK = 3105; - public static final int GL_INT = 5124; - public static final int GL_INTENSITY = 32841; - public static final int GL_INTENSITY12 = 32844; - public static final int GL_INTENSITY16 = 32845; - public static final int GL_INTENSITY4 = 32842; - public static final int GL_INTENSITY8 = 32843; - public static final int GL_INVALID_ENUM = 1280; - public static final int GL_INVALID_OPERATION = 1282; - public static final int GL_INVALID_VALUE = 1281; - public static final int GL_INVERT = 5386; - public static final int GL_KEEP = 7680; - public static final int GL_LEFT = 1030; - public static final int GL_LEQUAL = 515; - public static final int GL_LESS = 513; - public static final int GL_LIGHT_MODEL_AMBIENT = 2899; - public static final int GL_LIGHT_MODEL_LOCAL_VIEWER = 2897; - public static final int GL_LIGHT_MODEL_TWO_SIDE = 2898; - public static final int GL_LIGHT0 = 16384; - public static final int GL_LIGHT1 = 16385; - public static final int GL_LIGHT2 = 16386; - public static final int GL_LIGHT3 = 16387; - public static final int GL_LIGHT4 = 16388; - public static final int GL_LIGHT5 = 16389; - public static final int GL_LIGHT6 = 16390; - public static final int GL_LIGHT7 = 16391; - public static final int GL_LIGHTING = 2896; - public static final int GL_LIGHTING_BIT = 64; - public static final int GL_LINE = 6913; - public static final int GL_LINE_BIT = 4; - public static final int GL_LINE_LOOP = 2; - public static final int GL_LINE_RESET_TOKEN = 1799; - public static final int GL_LINE_SMOOTH = 2848; - public static final int GL_LINE_SMOOTH_HINT = 3154; - public static final int GL_LINE_STIPPLE = 2852; - public static final int GL_LINE_STIPPLE_PATTERN = 2853; - public static final int GL_LINE_STIPPLE_REPEAT = 2854; - public static final int GL_LINE_STRIP = 3; - public static final int GL_LINE_TOKEN = 1794; - public static final int GL_LINE_WIDTH = 2849; - public static final int GL_LINE_WIDTH_GRANULARITY = 2851; - public static final int GL_LINE_WIDTH_RANGE = 2850; - public static final int GL_LINEAR = 9729; - public static final int GL_LINEAR_ATTENUATION = 4616; - public static final int GL_LINEAR_MIPMAP_LINEAR = 9987; - public static final int GL_LINEAR_MIPMAP_NEAREST = 9985; - public static final int GL_LINES = 1; - public static final int GL_LIST_BASE = 2866; - public static final int GL_LIST_BIT = 0x20000; - public static final int GL_LIST_INDEX = 2867; - public static final int GL_LIST_MODE = 2864; - public static final int GL_LOAD = 257; - public static final int GL_LOGIC_OP = 3057; - public static final int GL_LOGIC_OP_MODE = 3056; - public static final int GL_LUMINANCE = 6409; - public static final int GL_LUMINANCE_ALPHA = 6410; - public static final int GL_LUMINANCE12 = 32833; - public static final int GL_LUMINANCE12_ALPHA12 = 32839; - public static final int GL_LUMINANCE12_ALPHA4 = 32838; - public static final int GL_LUMINANCE16 = 32834; - public static final int GL_LUMINANCE16_ALPHA16 = 32840; - public static final int GL_LUMINANCE4 = 32831; - public static final int GL_LUMINANCE4_ALPHA4 = 32835; - public static final int GL_LUMINANCE6_ALPHA2 = 32836; - public static final int GL_LUMINANCE8 = 32832; - public static final int GL_LUMINANCE8_ALPHA8 = 32837; - public static final int GL_MAP_COLOR = 3344; - public static final int GL_MAP_STENCIL = 3345; - public static final int GL_MAP1_COLOR_4 = 3472; - public static final int GL_MAP1_GRID_DOMAIN = 3536; - public static final int GL_MAP1_GRID_SEGMENTS = 3537; - public static final int GL_MAP1_INDEX = 3473; - public static final int GL_MAP1_NORMAL = 3474; - public static final int GL_MAP1_TEXTURE_COORD_1 = 3475; - public static final int GL_MAP1_TEXTURE_COORD_2 = 3476; - public static final int GL_MAP1_TEXTURE_COORD_3 = 3477; - public static final int GL_MAP1_TEXTURE_COORD_4 = 3478; - public static final int GL_MAP1_VERTEX_3 = 3479; - public static final int GL_MAP1_VERTEX_4 = 3480; - public static final int GL_MAP2_COLOR_4 = 3504; - public static final int GL_MAP2_GRID_DOMAIN = 3538; - public static final int GL_MAP2_GRID_SEGMENTS = 3539; - public static final int GL_MAP2_INDEX = 3505; - public static final int GL_MAP2_NORMAL = 3506; - public static final int GL_MAP2_TEXTURE_COORD_1 = 3507; - public static final int GL_MAP2_TEXTURE_COORD_2 = 3508; - public static final int GL_MAP2_TEXTURE_COORD_3 = 3509; - public static final int GL_MAP2_TEXTURE_COORD_4 = 3510; - public static final int GL_MAP2_VERTEX_3 = 3511; - public static final int GL_MAP2_VERTEX_4 = 3512; - public static final int GL_MATRIX_MODE = 2976; - public static final int GL_MAX_ATTRIB_STACK_DEPTH = 3381; - public static final int GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 3387; - public static final int GL_MAX_CLIP_PLANES = 3378; - public static final int GL_MAX_EVAL_ORDER = 3376; - public static final int GL_MAX_LIGHTS = 3377; - public static final int GL_MAX_LIST_NESTING = 2865; - public static final int GL_MAX_MODELVIEW_STACK_DEPTH = 3382; - public static final int GL_MAX_NAME_STACK_DEPTH = 3383; - public static final int GL_MAX_PIXEL_MAP_TABLE = 3380; - public static final int GL_MAX_PROJECTION_STACK_DEPTH = 3384; - public static final int GL_MAX_TEXTURE_SIZE = 3379; - public static final int GL_MAX_TEXTURE_STACK_DEPTH = 3385; - public static final int GL_MAX_VIEWPORT_DIMS = 3386; - public static final int GL_MODELVIEW = 5888; - public static final int GL_MODELVIEW_MATRIX = 2982; - public static final int GL_MODELVIEW_STACK_DEPTH = 2979; - public static final int GL_MODULATE = 8448; - public static final int GL_MULT = 259; - public static final int GL_N3F_V3F = 10789; - public static final int GL_NAME_STACK_DEPTH = 3440; - public static final int GL_NAND = 5390; - public static final int GL_NEAREST = 9728; - public static final int GL_NEAREST_MIPMAP_LINEAR = 9986; - public static final int GL_NEAREST_MIPMAP_NEAREST = 9984; - public static final int GL_NEVER = 512; - public static final int GL_NICEST = 4354; - public static final int GL_NO_ERROR = 0; - public static final int GL_NONE = 0; - public static final int GL_NOOP = 5381; - public static final int GL_NOR = 5384; - public static final int GL_NORMAL_ARRAY = 32885; - public static final int GL_NORMAL_ARRAY_POINTER = 32911; - public static final int GL_NORMAL_ARRAY_STRIDE = 32895; - public static final int GL_NORMAL_ARRAY_TYPE = 32894; - public static final int GL_NORMALIZE = 2977; - public static final int GL_NOTEQUAL = 517; - public static final int GL_OBJECT_LINEAR = 9217; - public static final int GL_OBJECT_PLANE = 9473; - public static final int GL_ONE = 1; - public static final int GL_ONE_MINUS_CONSTANT_ALPHA = 32772; - public static final int GL_ONE_MINUS_CONSTANT_COLOR = 32770; - public static final int GL_ONE_MINUS_DST_ALPHA = 773; - public static final int GL_ONE_MINUS_DST_COLOR = 775; - public static final int GL_ONE_MINUS_SRC_ALPHA = 771; - public static final int GL_ONE_MINUS_SRC_COLOR = 769; - public static final int GL_OR = 5383; - public static final int GL_OR_INVERTED = 5389; - public static final int GL_OR_REVERSE = 5387; - public static final int GL_ORDER = 2561; - public static final int GL_OUT_OF_MEMORY = 1285; - public static final int GL_PACK_ALIGNMENT = 3333; - public static final int GL_PACK_LSB_FIRST = 3329; - public static final int GL_PACK_ROW_LENGTH = 3330; - public static final int GL_PACK_SKIP_PIXELS = 3332; - public static final int GL_PACK_SKIP_ROWS = 3331; - public static final int GL_PACK_SWAP_BYTES = 3328; - public static final int GL_PASS_THROUGH_TOKEN = 1792; - public static final int GL_PERSPECTIVE_CORRECTION_HINT = 3152; - public static final int GL_PIXEL_MAP_A_TO_A = 3193; - public static final int GL_PIXEL_MAP_A_TO_A_SIZE = 3257; - public static final int GL_PIXEL_MAP_B_TO_B = 3192; - public static final int GL_PIXEL_MAP_B_TO_B_SIZE = 3256; - public static final int GL_PIXEL_MAP_G_TO_G = 3191; - public static final int GL_PIXEL_MAP_G_TO_G_SIZE = 3255; - public static final int GL_PIXEL_MAP_I_TO_A = 3189; - public static final int GL_PIXEL_MAP_I_TO_A_SIZE = 3253; - public static final int GL_PIXEL_MAP_I_TO_B = 3188; - public static final int GL_PIXEL_MAP_I_TO_B_SIZE = 3252; - public static final int GL_PIXEL_MAP_I_TO_G = 3187; - public static final int GL_PIXEL_MAP_I_TO_G_SIZE = 3251; - public static final int GL_PIXEL_MAP_I_TO_I = 3184; - public static final int GL_PIXEL_MAP_I_TO_I_SIZE = 3248; - public static final int GL_PIXEL_MAP_I_TO_R = 3186; - public static final int GL_PIXEL_MAP_I_TO_R_SIZE = 3250; - public static final int GL_PIXEL_MAP_R_TO_R = 3190; - public static final int GL_PIXEL_MAP_R_TO_R_SIZE = 3254; - public static final int GL_PIXEL_MAP_S_TO_S = 3185; - public static final int GL_PIXEL_MAP_S_TO_S_SIZE = 3249; - public static final int GL_PIXEL_MODE_BIT = 32; - public static final int GL_POINT = 6912; - public static final int GL_POINT_BIT = 2; - public static final int GL_POINT_SIZE = 2833; - public static final int GL_POINT_SIZE_GRANULARITY = 2835; - public static final int GL_POINT_SIZE_RANGE = 2834; - public static final int GL_POINT_SMOOTH = 2832; - public static final int GL_POINT_SMOOTH_HINT = 3153; - public static final int GL_POINT_TOKEN = 1793; - public static final int GL_POINTS = 0; - public static final int GL_POLYGON = 9; - public static final int GL_POLYGON_BIT = 8; - public static final int GL_POLYGON_MODE = 2880; - public static final int GL_POLYGON_OFFSET_FACTOR = 32824; - public static final int GL_POLYGON_OFFSET_FILL = 32823; - public static final int GL_POLYGON_OFFSET_LINE = 10754; - public static final int GL_POLYGON_OFFSET_POINT = 10753; - public static final int GL_POLYGON_OFFSET_UNITS = 10752; - public static final int GL_POLYGON_SMOOTH = 2881; - public static final int GL_POLYGON_SMOOTH_HINT = 3155; - public static final int GL_POLYGON_STIPPLE = 2882; - public static final int GL_POLYGON_STIPPLE_BIT = 16; - public static final int GL_POLYGON_TOKEN = 1795; - public static final int GL_POSITION = 4611; - public static final int GL_PROJECTION = 5889; - public static final int GL_PROJECTION_MATRIX = 2983; - public static final int GL_PROJECTION_STACK_DEPTH = 2980; - public static final int GL_PROXY_TEXTURE_1D = 32867; - public static final int GL_PROXY_TEXTURE_2D = 32868; - public static final int GL_Q = 8195; - public static final int GL_QUAD_STRIP = 8; - public static final int GL_QUADRATIC_ATTENUATION = 4617; - public static final int GL_QUADS = 7; - public static final int GL_R = 8194; - public static final int GL_R3_G3_B2 = 10768; - public static final int GL_READ_BUFFER = 3074; - public static final int GL_RED = 6403; - public static final int GL_RED_BIAS = 3349; - public static final int GL_RED_BITS = 3410; - public static final int GL_RED_SCALE = 3348; - public static final int GL_RENDER = 7168; - public static final int GL_RENDER_MODE = 3136; - public static final int GL_RENDERER = 7937; - public static final int GL_REPEAT = 10497; - public static final int GL_REPLACE = 7681; - public static final int GL_RETURN = 258; - public static final int GL_RGB = 6407; - public static final int GL_RGB10 = 32850; - public static final int GL_RGB10_A2 = 32857; - public static final int GL_RGB12 = 32851; - public static final int GL_RGB16 = 32852; - public static final int GL_RGB4 = 32847; - public static final int GL_RGB5 = 32848; - public static final int GL_RGB5_A1 = 32855; - public static final int GL_RGB8 = 32849; - public static final int GL_RGBA = 6408; - public static final int GL_RGBA_MODE = 3121; - public static final int GL_RGBA12 = 32858; - public static final int GL_RGBA16 = 32859; - public static final int GL_RGBA2 = 32853; - public static final int GL_RGBA4 = 32854; - public static final int GL_RGBA8 = 32856; - public static final int GL_RIGHT = 1031; - public static final int GL_S = 8192; - public static final int GL_SCISSOR_BIT = 0x80000; - public static final int GL_SCISSOR_BOX = 3088; - public static final int GL_SCISSOR_TEST = 3089; - public static final int GL_SELECT = 7170; - public static final int GL_SELECTION_BUFFER_POINTER = 3571; - public static final int GL_SELECTION_BUFFER_SIZE = 3572; - public static final int GL_SET = 5391; - public static final int GL_SHADE_MODEL = 2900; - public static final int GL_SHININESS = 5633; - public static final int GL_SHORT = 5122; - public static final int GL_SMOOTH = 7425; - public static final int GL_SPECULAR = 4610; - public static final int GL_SPHERE_MAP = 9218; - public static final int GL_SPOT_CUTOFF = 4614; - public static final int GL_SPOT_DIRECTION = 4612; - public static final int GL_SPOT_EXPONENT = 4613; - public static final int GL_SRC_ALPHA = 770; - public static final int GL_SRC_ALPHA_SATURATE = 776; - public static final int GL_SRC_COLOR = 768; - public static final int GL_STACK_OVERFLOW = 1283; - public static final int GL_STACK_UNDERFLOW = 1284; - public static final int GL_STENCIL = 6146; - public static final int GL_STENCIL_BITS = 3415; - public static final int GL_STENCIL_BUFFER_BIT = 1024; - public static final int GL_STENCIL_CLEAR_VALUE = 2961; - public static final int GL_STENCIL_FAIL = 2964; - public static final int GL_STENCIL_FUNC = 2962; - public static final int GL_STENCIL_INDEX = 6401; - public static final int GL_STENCIL_PASS_DEPTH_FAIL = 2965; - public static final int GL_STENCIL_PASS_DEPTH_PASS = 2966; - public static final int GL_STENCIL_REF = 2967; - public static final int GL_STENCIL_TEST = 2960; - public static final int GL_STENCIL_VALUE_MASK = 2963; - public static final int GL_STENCIL_WRITEMASK = 2968; - public static final int GL_STEREO = 3123; - public static final int GL_SUBPIXEL_BITS = 3408; - public static final int GL_T = 8193; - public static final int GL_T2F_C3F_V3F = 10794; - public static final int GL_T2F_C4F_N3F_V3F = 10796; - public static final int GL_T2F_C4UB_V3F = 10793; - public static final int GL_T2F_N3F_V3F = 10795; - public static final int GL_T2F_V3F = 10791; - public static final int GL_T4F_C4F_N3F_V4F = 10797; - public static final int GL_T4F_V4F = 10792; - public static final int GL_TEXTURE = 5890; - public static final int GL_TEXTURE_1D = 3552; - public static final int GL_TEXTURE_2D = 3553; - public static final int GL_TEXTURE_ALPHA_SIZE = 32863; - public static final int GL_TEXTURE_BINDING_1D = 32872; - public static final int GL_TEXTURE_BINDING_2D = 32873; - public static final int GL_TEXTURE_BIT = 0x40000; - public static final int GL_TEXTURE_BLUE_SIZE = 32862; - public static final int GL_TEXTURE_BORDER = 4101; - public static final int GL_TEXTURE_BORDER_COLOR = 4100; - public static final int GL_TEXTURE_COMPONENTS = 4099; - public static final int GL_TEXTURE_COORD_ARRAY = 32888; - public static final int GL_TEXTURE_COORD_ARRAY_POINTER = 32914; - public static final int GL_TEXTURE_COORD_ARRAY_SIZE = 32904; - public static final int GL_TEXTURE_COORD_ARRAY_STRIDE = 32906; - public static final int GL_TEXTURE_COORD_ARRAY_TYPE = 32905; - public static final int GL_TEXTURE_ENV = 8960; - public static final int GL_TEXTURE_ENV_COLOR = 8705; - public static final int GL_TEXTURE_ENV_MODE = 8704; - public static final int GL_TEXTURE_GEN_MODE = 9472; - public static final int GL_TEXTURE_GEN_Q = 3171; - public static final int GL_TEXTURE_GEN_R = 3170; - public static final int GL_TEXTURE_GEN_S = 3168; - public static final int GL_TEXTURE_GEN_T = 3169; - public static final int GL_TEXTURE_GREEN_SIZE = 32861; - public static final int GL_TEXTURE_HEIGHT = 4097; - public static final int GL_TEXTURE_INTENSITY_SIZE = 32865; - public static final int GL_TEXTURE_INTERNAL_FORMAT = 4099; - public static final int GL_TEXTURE_LUMINANCE_SIZE = 32864; - public static final int GL_TEXTURE_MAG_FILTER = 10240; - public static final int GL_TEXTURE_MATRIX = 2984; - public static final int GL_TEXTURE_MIN_FILTER = 10241; - public static final int GL_TEXTURE_PRIORITY = 32870; - public static final int GL_TEXTURE_RED_SIZE = 32860; - public static final int GL_TEXTURE_RESIDENT = 32871; - public static final int GL_TEXTURE_STACK_DEPTH = 2981; - public static final int GL_TEXTURE_WIDTH = 4096; - public static final int GL_TEXTURE_WRAP_S = 10242; - public static final int GL_TEXTURE_WRAP_T = 10243; - public static final int GL_TRANSFORM_BIT = 4096; - public static final int GL_TRIANGLE_FAN = 6; - public static final int GL_TRIANGLE_STRIP = 5; - public static final int GL_TRIANGLES = 4; - public static final int GL_TRUE = 1; - public static final int GL_UNPACK_ALIGNMENT = 3317; - public static final int GL_UNPACK_LSB_FIRST = 3313; - public static final int GL_UNPACK_ROW_LENGTH = 3314; - public static final int GL_UNPACK_SKIP_PIXELS = 3316; - public static final int GL_UNPACK_SKIP_ROWS = 3315; - public static final int GL_UNPACK_SWAP_BYTES = 3312; - public static final int GL_UNSIGNED_BYTE = 5121; - public static final int GL_UNSIGNED_INT = 5125; - public static final int GL_UNSIGNED_SHORT = 5123; - public static final int GL_V2F = 10784; - public static final int GL_V3F = 10785; - public static final int GL_VENDOR = 7936; - public static final int GL_VERSION = 7938; - public static final int GL_VERTEX_ARRAY = 32884; - public static final int GL_VERTEX_ARRAY_POINTER = 32910; - public static final int GL_VERTEX_ARRAY_SIZE = 32890; - public static final int GL_VERTEX_ARRAY_STRIDE = 32892; - public static final int GL_VERTEX_ARRAY_TYPE = 32891; - public static final int GL_VIEWPORT = 2978; - public static final int GL_VIEWPORT_BIT = 2048; - public static final int GL_XOR = 5382; - public static final int GL_ZERO = 0; - public static final int GL_ZOOM_X = 3350; - public static final int GL_ZOOM_Y = 3351; - - - void glActiveTextureARB(int texture); - void glBegin(int gl_triangle_fan2); - void glBindTexture(int gl_texture_2d2, int texnum); - void glBlendFunc(int gl_src_alpha2, int gl_one_minus_src_alpha2); - void glClear(int gl_color_buffer_bit2); - void glClearColor(float f, float g, float h, float i); - void glClientActiveTextureARB(int texture); - void glColor3f(float f, float g, float h); - void glColor3ub(byte b, byte c, byte d); - void glColor4f(float intens, float intens2, float intens3, float f); - void glColor4f(int i, int j, int k, float f); - void glColor4ub(byte b, byte c, byte d, byte e); - void glColorPointer(int i, int gl_float2, int j, FloatBuffer colorArrayBuf); - void glColorPointer(int i, int gl_unsigned_byte2, int j, ByteBuffer bb); - void glCullFace(int gl_back2); - void glDepthFunc(int gl_lequal2); - void glDepthMask(boolean b); - void glDepthRange(float gldepthmin, double d); - void glDisable(int gl_texture_2d2); - void glDisableClientState(int gl_color_array2); - void glDrawArrays(int gl_polygon2, int pos, int numverts); - void glDrawElements(int mode, int count, int gl_unsigned_int2, IntBuffer srcIndexBuf); - void glEnable(int gl_alpha_test2); - void glEnableClientState(int gl_color_array2); - void glEnd(); - void glFrustum(double xmin, double xmax, double ymin, double ymax, double near, double far); - void glInterleavedArrays(int gl_t2f_v3f2, int byte_stride, FloatBuffer globalPolygonInterleavedBuf); - void glLoadIdentity(); - void glLoadMatrixf(float[] r_world_matrix); - void glMatrixMode(int gl_projection2); - void glOrtho(int i, int width, int height, int j, int k, int l); - void glPointSize(float value); - void glPopMatrix(); - void glPushMatrix(); - void glRotatef(float f, float g, float h, float i); - void glScalef(int i, int j, int k); - void glShadeModel(int gl_smooth2); - void glTexCoord2f(float s, float t); - void glTexCoordPointer(int i, int gl_float2, int j, FloatBuffer textureArrayBuf); - void glTexEnvi(int gl_texture_env2, int gl_texture_env_mode2, int mode); - void glTexImage2D(int gl_texture_2d2, int i, int gl_color_index8_ext, int j, int k, int l, int gl_color_index2, int gl_unsigned_byte2, ByteBuffer image8); - void glTexImage2D(int gl_texture_2d2, int i, int gl_tex_solid_format, int j, int k, int l, int gl_rgba3, int gl_unsigned_byte2, IntBuffer image32); - void glTexParameterf(int gl_texture_2d, int gl_texture_min_filter, int gl_nearest); - void glTexParameteri(int gl_texture_2d2, int gl_texture_min_filter2, int gl_filter_min); - void glTexSubImage2D(int gl_texture_2d2, int i, int j, int k, int lm_block_width, int height, int gl_lightmap_format, int gl_unsigned_byte2, IntBuffer lightmap_buffer); - void glTranslatef(float f, float g, float h); - void glVertex2f(int x, int i); - void glVertex3f(float f, float g, float h); - void glVertexPointer(int i, int gl_float2, int j, FloatBuffer vertexArrayBuf); - void glViewport(int i, int j, int width, int height); -} diff --git a/src/jake2/render/common/Image.java b/src/jake2/render/common/Image.java deleted file mode 100644 index f9a9546..0000000 --- a/src/jake2/render/common/Image.java +++ /dev/null @@ -1,1223 +0,0 @@ -/* -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. - -*/ - -// Created on 20.08.2006 by RST. - -// $Id: Image.java,v 1.1 2006-10-31 13:06:32 salomo Exp $ - -package jake2.render.common; - - -import jake2.Defines; -import jake2.client.VID; -import jake2.client.particle_t; -import jake2.game.cvar_t; -import jake2.qcommon.*; -import jake2.render.image_t; -import jake2.util.Vargs; - -import java.awt.Dimension; -import java.awt.geom.AffineTransform; -import java.awt.image.AffineTransformOp; -import java.awt.image.BufferedImage; -import java.nio.ByteBuffer; - - -public abstract class Image extends Main { - - public static class pos_t { - public int x, y; - - public pos_t(int x, int y) { - this.x = x; - this.y = y; - } - } - - public static class floodfill_t { - public short x, y; - } - - protected static final int MAX_SCRAPS = 1; - - protected static final int BLOCK_WIDTH = 256; - - protected static final int BLOCK_HEIGHT = 256; - - protected int[][] scrap_allocated = new int[MAX_SCRAPS][BLOCK_WIDTH]; - - protected byte[][] scrap_texels = new byte[MAX_SCRAPS][BLOCK_WIDTH * BLOCK_HEIGHT]; - - protected boolean scrap_dirty; - - // must be a power of 2 - protected static final int FLOODFILL_FIFO_SIZE = 0x1000; - - protected static final int FLOODFILL_FIFO_MASK = FLOODFILL_FIFO_SIZE - 1; - - protected static floodfill_t[] fifo = new floodfill_t[FLOODFILL_FIFO_SIZE]; - static { - for (int j = 0; j < fifo.length; j++) { - fifo[j] = new floodfill_t(); - } - } - - - // gltmode_t - public static class gltmode_t { - - public String name; - public int mode; - - public gltmode_t(String name, int mode) { - this.name = name; - this.mode = mode; - } - } - - // glmode_t - public static class glmode_t { - - public String name; - public int minimize, maximize; - - public glmode_t(String name, int minimize, int maximze) { - this.name = name; - this.minimize = minimize; - this.maximize = maximze; - } - } - - protected glmode_t[] getGLModes() - { - return new glmode_t[]{ - new glmode_t("GL_NEAREST", ggl.GL_NEAREST, ggl.GL_NEAREST), - new glmode_t("GL_LINEAR", ggl.GL_LINEAR, ggl.GL_LINEAR), - new glmode_t("GL_NEAREST_MIPMAP_NEAREST", - ggl.GL_NEAREST_MIPMAP_NEAREST, ggl.GL_NEAREST), - new glmode_t("GL_LINEAR_MIPMAP_NEAREST", - ggl.GL_LINEAR_MIPMAP_NEAREST, ggl.GL_LINEAR), - new glmode_t("GL_NEAREST_MIPMAP_LINEAR", - ggl.GL_NEAREST_MIPMAP_LINEAR, ggl.GL_NEAREST), - new glmode_t("GL_LINEAR_MIPMAP_LINEAR", ggl.GL_LINEAR_MIPMAP_LINEAR, - ggl.GL_LINEAR) }; - } - - - protected gltmode_t[] getGLAlphaModes() - { - return new gltmode_t[] { - new gltmode_t("default", 4), - new gltmode_t("GL_RGBA", ggl.GL_RGBA), - new gltmode_t("GL_RGBA8", ggl.GL_RGBA8), - new gltmode_t("GL_RGB5_A1", ggl.GL_RGB5_A1), - new gltmode_t("GL_RGBA4", ggl.GL_RGBA4), - new gltmode_t("GL_RGBA2", ggl.GL_RGBA2) - }; - } - - protected gltmode_t[] getGLSolidModes() - { - return new gltmode_t[] { - new gltmode_t("default", 3), - new gltmode_t("GL_RGB", ggl.GL_RGB), - new gltmode_t("GL_RGB8", ggl.GL_RGB8), - new gltmode_t("GL_RGB5", ggl.GL_RGB5), - new gltmode_t("GL_RGB4", ggl.GL_RGB4), - new gltmode_t("GL_R3_G3_B2", ggl.GL_R3_G3_B2), - //new gltmode_t("GL_RGB2", GL.GL_RGB2_EXT); - }; - } - - protected image_t draw_chars; - - protected image_t[] gltextures = new image_t[MAX_GLTEXTURES]; - - protected int numgltextures; - - protected int base_textureid; // gltextures[i] = base_textureid+i - - protected byte[] intensitytable = new byte[256]; - - protected byte[] gammatable = new byte[256]; - - protected cvar_t intensity; - - public Image() { - // init the texture cache - for (int i = 0; i < gltextures.length; i++) { - gltextures[i] = new image_t(i); - } - numgltextures = 0; - } - - protected int gl_solid_format = 3; - protected int gl_alpha_format = 4; - protected int gl_tex_solid_format = 3; - protected int gl_tex_alpha_format = 4; - - protected int gl_filter_min = ggl.GL_LINEAR_MIPMAP_NEAREST; - protected int gl_filter_max = ggl.GL_LINEAR; - - protected int upload_width, upload_height; - - protected boolean uploaded_paletted; - - - /** - * GL_TextureAlphaMode - */ - protected void GL_TextureAlphaMode(String string) { - - int i; - - gltmode_t [] gl_alpha_modes = getGLAlphaModes(); - - for (i = 0; i < gl_alpha_modes.length ; i++) { - if (gl_alpha_modes[i].name.equalsIgnoreCase(string)) - break; - } - - if (i == gl_alpha_modes.length) { - VID.Printf(Defines.PRINT_ALL, "bad alpha texture mode name: [" + string + "]\n"); - return; - } - - gl_tex_alpha_format = gl_alpha_modes[i].mode; - } - - /** - * GL_TextureSolidMode - */ - protected void GL_TextureSolidMode(String string) { - - int i; - - gltmode_t [] gl_solid_modes = getGLAlphaModes(); - - for (i = 0; i < gl_solid_modes.length; i++) { - if (gl_solid_modes[i].name.equalsIgnoreCase(string)) - break; - } - - if (i == gl_solid_modes.length) { - VID.Printf(Defines.PRINT_ALL, "bad solid texture mode name: [" + string + "]\n"); - return; - } - - gl_tex_solid_format = gl_solid_modes[i].mode; - } - - /** - * GL_TextureMode - */ - protected void GL_TextureMode(String string) { - - int i; - glmode_t modes [] = getGLModes(); - for (i = 0; i < modes.length; i++) { - if (modes[i].name.equalsIgnoreCase(string)) - break; - } - - if (i == modes.length) { - VID.Printf(Defines.PRINT_ALL, "bad filter name: [" + string + "]\n"); - return; - } - - gl_filter_min = modes[i].minimize; - gl_filter_max = modes[i].maximize; - - image_t glt; - // change all the existing mipmap texture objects - for (i = 0; i < numgltextures; i++) { - glt = gltextures[i]; - - if (glt.type != it_pic && glt.type != it_sky) { - GL_Bind(glt.texnum); - ggl.glTexParameteri(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, gl_filter_min); - ggl.glTexParameteri(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, gl_filter_max); - } - } - } - - - protected void GL_EnableMultitexture(boolean enable) { - if (enable) { - GL_SelectTexture(GL_TEXTURE1); - ggl.glEnable(ggl.GL_TEXTURE_2D); - GL_TexEnv(ggl.GL_REPLACE); - } else { - GL_SelectTexture(GL_TEXTURE1); - ggl.glDisable(ggl.GL_TEXTURE_2D); - GL_TexEnv(ggl.GL_REPLACE); - } - GL_SelectTexture(GL_TEXTURE0); - GL_TexEnv(ggl.GL_REPLACE); - } - - protected void GL_SelectTexture(int texture) { - int tmu; - - tmu = (texture == GL_TEXTURE0) ? 0 : 1; - - if (tmu == gl_state.currenttmu) { - return; - } - - gl_state.currenttmu = tmu; - - ggl.glActiveTextureARB(texture); - ggl.glClientActiveTextureARB(texture); - } - - int[] lastmodes = { -1, -1 }; - - protected void GL_TexEnv(int mode) { - - if (mode != lastmodes[gl_state.currenttmu]) { - ggl.glTexEnvi(ggl.GL_TEXTURE_ENV, ggl.GL_TEXTURE_ENV_MODE, mode); - lastmodes[gl_state.currenttmu] = mode; - } - } - - /** - * GL_ImageList_f - */ - protected void GL_ImageList_f() { - - image_t image; - int texels; - final String[] palstrings = { "RGB", "PAL" }; - - VID.Printf(Defines.PRINT_ALL, "------------------\n"); - texels = 0; - - for (int i = 0; i < numgltextures; i++) { - image = gltextures[i]; - if (image.texnum <= 0) - continue; - - texels += image.upload_width * image.upload_height; - switch (image.type) { - case it_skin: - VID.Printf(Defines.PRINT_ALL, "M"); - break; - case it_sprite: - VID.Printf(Defines.PRINT_ALL, "S"); - break; - case it_wall: - VID.Printf(Defines.PRINT_ALL, "W"); - break; - case it_pic: - VID.Printf(Defines.PRINT_ALL, "P"); - break; - default: - VID.Printf(Defines.PRINT_ALL, " "); - break; - } - - VID.Printf(Defines.PRINT_ALL, " %3i %3i %s: %s\n", new Vargs(4).add(image.upload_width). - add(image.upload_height).add(palstrings[(image.paletted) ? 1 : 0]).add(image.name)); - } - VID.Printf(Defines.PRINT_ALL, "Total texel count (not counting mipmaps): " + texels + '\n'); - } - - /* - * ============================================================================= - * - * scrap allocation - * - * Allocate all the little status bar objects into a single texture to - * crutch up inefficient hardware / drivers - * - * ============================================================================= - */ - - - /** - * Returns a texture number and the position inside it. - */ - protected int Scrap_AllocBlock(int w, int h, pos_t pos) { - int i, j; - int best, best2; - int texnum; - - for (texnum = 0; texnum < MAX_SCRAPS; texnum++) { - best = BLOCK_HEIGHT; - - for (i = 0; i < BLOCK_WIDTH - w; i++) { - best2 = 0; - - for (j = 0; j < w; j++) { - if (scrap_allocated[texnum][i + j] >= best) - break; - if (scrap_allocated[texnum][i + j] > best2) - best2 = scrap_allocated[texnum][i + j]; - } - if (j == w) { // this is a valid spot - pos.x = i; - pos.y = best = best2; - } - } - - if (best + h > BLOCK_HEIGHT) - continue; - - for (i = 0; i < w; i++) - scrap_allocated[texnum][pos.x + i] = best + h; - - return texnum; - } - - return -1; - } - - /** - * Mod_FloodFillSkin - * - * Fill background pixels so mipmapping doesn't have haloes - */ - - // TODO check this - protected void R_FloodFillSkin(byte[] skin, int skinwidth, int skinheight) { - // assume this is the pixel to fill - int fillcolor = skin[0] & 0xFF; - int inpt = 0, outpt = 0; - int filledcolor = -1; - int i; - - - if (filledcolor == -1) { - filledcolor = 0; - // attempt to find opaque black - for (i = 0; i < 256; ++i) - if (d_8to24table[i] == 0xFF000000) { // alpha - // 1.0 - filledcolor = i; - break; - } - } - - // can't fill to filled color or to transparent color (used as visited - // marker) - if ((fillcolor == filledcolor) || (fillcolor == 255)) { - return; - } - - fifo[inpt].x = 0; - fifo[inpt].y = 0; - inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; - - while (outpt != inpt) { - int x = fifo[outpt].x; - int y = fifo[outpt].y; - int fdc = filledcolor; - int pos = x + skinwidth * y; - // - outpt = (outpt + 1) & FLOODFILL_FIFO_MASK; - - int off, dx, dy; - - if (x > 0) { - // FLOODFILL_STEP( -1, -1, 0 ); - off = -1; - dx = -1; - dy = 0; - if (skin[pos + off] == (byte) fillcolor) { - skin[pos + off] = (byte) 255; - fifo[inpt].x = (short) (x + dx); - fifo[inpt].y = (short) (y + dy); - inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; - } else if (skin[pos + off] != (byte) 255) - fdc = skin[pos + off] & 0xff; - } - - if (x < skinwidth - 1) { - // FLOODFILL_STEP( 1, 1, 0 ); - off = 1; - dx = 1; - dy = 0; - if (skin[pos + off] == (byte) fillcolor) { - skin[pos + off] = (byte) 255; - fifo[inpt].x = (short) (x + dx); - fifo[inpt].y = (short) (y + dy); - inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; - } else if (skin[pos + off] != (byte) 255) - fdc = skin[pos + off] & 0xff; - } - - if (y > 0) { - // FLOODFILL_STEP( -skinwidth, 0, -1 ); - off = -skinwidth; - dx = 0; - dy = -1; - if (skin[pos + off] == (byte) fillcolor) { - skin[pos + off] = (byte) 255; - fifo[inpt].x = (short) (x + dx); - fifo[inpt].y = (short) (y + dy); - inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; - } else if (skin[pos + off] != (byte) 255) - fdc = skin[pos + off] & 0xff; - } - - if (y < skinheight - 1) { - // FLOODFILL_STEP( skinwidth, 0, 1 ); - off = skinwidth; - dx = 0; - dy = 1; - if (skin[pos + off] == (byte) fillcolor) { - skin[pos + off] = (byte) 255; - fifo[inpt].x = (short) (x + dx); - fifo[inpt].y = (short) (y + dy); - inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; - } else if (skin[pos + off] != (byte) 255) - fdc = skin[pos + off] & 0xff; - - } - - skin[x + skinwidth * y] = (byte) fdc; - } - } - - /** - * GL_ResampleTexture, simplified by cwei. - */ - protected void GL_ResampleTexture(int[] in, int inwidth, int inheight, int[] out, - int outwidth, int outheight) { - - BufferedImage image = new BufferedImage(inwidth, inheight, - BufferedImage.TYPE_INT_ARGB); - - image.setRGB(0, 0, inwidth, inheight, in, 0, inwidth); - - AffineTransformOp op = new AffineTransformOp( - AffineTransform.getScaleInstance(outwidth * 1.0 / inwidth, outheight * 1.0 / inheight), - AffineTransformOp.TYPE_NEAREST_NEIGHBOR); - BufferedImage tmp = op.filter(image, null); - - tmp.getRGB(0, 0, outwidth, outheight, out, 0, outwidth); - } - - /** - * GL_LightScaleTexture, Scale up the pixel values in a texture to increase the lighting range. - */ - protected void GL_LightScaleTexture(int[] in, int inwidth, int inheight, boolean only_gamma) { - if (only_gamma) { - int i, c; - int r, g, b, color; - - c = inwidth * inheight; - for (i = 0; i < c; i++) { - color = in[i]; - r = (color >> 0) & 0xFF; - g = (color >> 8) & 0xFF; - b = (color >> 16) & 0xFF; - - r = gammatable[r] & 0xFF; - g = gammatable[g] & 0xFF; - b = gammatable[b] & 0xFF; - - in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000); - } - } else { - int i, c; - int r, g, b, color; - - c = inwidth * inheight; - for (i = 0; i < c; i++) { - color = in[i]; - r = (color >> 0) & 0xFF; - g = (color >> 8) & 0xFF; - b = (color >> 16) & 0xFF; - - r = gammatable[intensitytable[r] & 0xFF] & 0xFF; - g = gammatable[intensitytable[g] & 0xFF] & 0xFF; - b = gammatable[intensitytable[b] & 0xFF] & 0xFF; - - in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000); - } - - } - } - - /** - * GL_MipMap - * - * Operates in place, quartering the size of the texture - */ - protected void GL_MipMap(int[] in, int width, int height) { - int i, j; - int[] out; - - out = in; - - int inIndex = 0; - int outIndex = 0; - - int r, g, b, a; - int p1, p2, p3, p4; - - for (i = 0; i < height; i += 2, inIndex += width) { - for (j = 0; j < width; j += 2, outIndex += 1, inIndex += 2) { - - p1 = in[inIndex + 0]; - p2 = in[inIndex + 1]; - p3 = in[inIndex + width + 0]; - p4 = in[inIndex + width + 1]; - - r = (((p1 >> 0) & 0xFF) + ((p2 >> 0) & 0xFF) + ((p3 >> 0) & 0xFF) + ((p4 >> 0) & 0xFF)) >> 2; - g = (((p1 >> 8) & 0xFF) + ((p2 >> 8) & 0xFF) + ((p3 >> 8) & 0xFF) + ((p4 >> 8) & 0xFF)) >> 2; - b = (((p1 >> 16) & 0xFF) + ((p2 >> 16) & 0xFF) + ((p3 >> 16) & 0xFF) + ((p4 >> 16) & 0xFF)) >> 2; - a = (((p1 >> 24) & 0xFF) + ((p2 >> 24) & 0xFF) + ((p3 >> 24) & 0xFF) + ((p4 >> 24) & 0xFF)) >> 2; - - out[outIndex] = (r << 0) | (g << 8) | (b << 16) | (a << 24); - } - } - } - - /** - * GL_InitImages - */ - protected void GL_InitImages() { - int i, j; - float g = vid_gamma.value; - - registration_sequence = 1; - - // init intensity conversions - intensity = Cvar.Get("intensity", "2", 0); - - if (intensity.value <= 1) - Cvar.Set("intensity", "1"); - - gl_state.inverse_intensity = 1 / intensity.value; - - Draw_GetPalette(); - - if (qglColorTableEXT) { - gl_state.d_16to8table = FS.LoadFile("pics/16to8.dat"); - if (gl_state.d_16to8table == null) - Com.Error(Defines.ERR_FATAL, "Couldn't load pics/16to8.pcx"); - } - - if ((gl_config.renderer & (GL_RENDERER_VOODOO | GL_RENDERER_VOODOO2)) != 0) { - g = 1.0F; - } - - for (i = 0; i < 256; i++) { - - if (g == 1.0f) { - gammatable[i] = (byte) i; - } else { - - int inf = (int) (255.0f * Math.pow((i + 0.5) / 255.5, g) + 0.5); - if (inf < 0) - inf = 0; - if (inf > 255) - inf = 255; - gammatable[i] = (byte) inf; - } - } - - for (i = 0; i < 256; i++) { - j = (int) (i * intensity.value); - if (j > 255) - j = 255; - intensitytable[i] = (byte) j; - } - } - - /** - * GL_LoadPic - * This is also used as an entry point for the generated r_notexture. - */ - protected image_t GL_LoadPic(String name, byte[] pic, int width, int height, - int type, int bits) { - image_t image; - int i; - - // find a free image_t - for (i = 0; i < numgltextures; i++) { - image = gltextures[i]; - if (image.texnum == 0) - break; - } - - if (i == numgltextures) { - if (numgltextures == MAX_GLTEXTURES) - Com.Error(Defines.ERR_DROP, "MAX_GLTEXTURES"); - - numgltextures++; - } - image = gltextures[i]; - - if (name.length() > Defines.MAX_QPATH) - Com.Error(Defines.ERR_DROP, "Draw_LoadPic: \"" + name - + "\" is too long"); - - image.name = name; - image.registration_sequence = registration_sequence; - - image.width = width; - image.height = height; - image.type = type; - - if (type == it_skin && bits == 8) - R_FloodFillSkin(pic, width, height); - - // load little pics into the scrap - if (image.type == it_pic && bits == 8 && image.width < 64 - && image.height < 64) { - pos_t pos = new pos_t(0, 0); - int j, k; - - int texnum = Scrap_AllocBlock(image.width, image.height, pos); - - if (texnum == -1) { - // replace goto nonscrap - - image.scrap = false; - - image.texnum = TEXNUM_IMAGES + image.getId(); // image pos in - // array - GL_Bind(image.texnum); - - if (bits == 8) { - image.has_alpha = GL_Upload8(pic, width, height, - (image.type != it_pic && image.type != it_sky), - image.type == it_sky); - } else { - int[] tmp = new int[pic.length / 4]; - - for (i = 0; i < tmp.length; i++) { - tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF; - tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00; - tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000; - tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000; - } - - image.has_alpha = GL_Upload32(tmp, width, height, - (image.type != it_pic && image.type != it_sky)); - } - - image.upload_width = upload_width; // after power of 2 and scales - image.upload_height = upload_height; - image.paletted = uploaded_paletted; - image.sl = 0; - image.sh = 1; - image.tl = 0; - image.th = 1; - - return image; - } - - scrap_dirty = true; - - // copy the texels into the scrap block - k = 0; - for (i = 0; i < image.height; i++) - for (j = 0; j < image.width; j++, k++) - scrap_texels[texnum][(pos.y + i) * BLOCK_WIDTH + pos.x + j] = pic[k]; - - image.texnum = TEXNUM_SCRAPS + texnum; - image.scrap = true; - image.has_alpha = true; - image.sl = (pos.x + 0.01f) / (float) BLOCK_WIDTH; - image.sh = (pos.x + image.width - 0.01f) / (float) BLOCK_WIDTH; - image.tl = (pos.y + 0.01f) / (float) BLOCK_WIDTH; - image.th = (pos.y + image.height - 0.01f) / (float) BLOCK_WIDTH; - - } else { - // this was label nonscrap - - image.scrap = false; - - image.texnum = TEXNUM_IMAGES + image.getId(); // image pos in - // array - GL_Bind(image.texnum); - - if (bits == 8) { - image.has_alpha = GL_Upload8(pic, width, height, - (image.type != it_pic && image.type != it_sky), - image.type == it_sky); - } else { - int[] tmp = new int[pic.length / 4]; - - for (i = 0; i < tmp.length; i++) { - tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF; - tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00; - tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000; - tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000; - } - - image.has_alpha = GL_Upload32(tmp, width, height, - (image.type != it_pic && image.type != it_sky)); - } - image.upload_width = upload_width; // after power of 2 and scales - image.upload_height = upload_height; - image.paletted = uploaded_paletted; - image.sl = 0; - image.sh = 1; - image.tl = 0; - image.th = 1; - } - return image; - } - - - /** - * LoadPCX - */ - protected byte[] LoadPCX(String filename, byte[][] palette, Dimension dim) { - qfiles.pcx_t pcx; - - // - // load the file - // - byte[] raw = FS.LoadFile(filename); - - if (raw == null) { - VID.Printf(Defines.PRINT_DEVELOPER, "Bad pcx file " + filename - + '\n'); - return null; - } - - // - // parse the PCX file - // - pcx = new qfiles.pcx_t(raw); - - if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 - || pcx.bits_per_pixel != 8 || pcx.xmax >= 640 - || pcx.ymax >= 480) { - - VID.Printf(Defines.PRINT_ALL, "Bad pcx file " + filename + '\n'); - return null; - } - - int width = pcx.xmax - pcx.xmin + 1; - int height = pcx.ymax - pcx.ymin + 1; - - byte[] pix = new byte[width * height]; - - if (palette != null) { - palette[0] = new byte[768]; - System.arraycopy(raw, raw.length - 768, palette[0], 0, 768); - } - - if (dim != null) { - dim.width = width; - dim.height = height; - } - - // - // decode pcx - // - int count = 0; - byte dataByte = 0; - int runLength = 0; - int x, y; - - for (y = 0; y < height; y++) { - for (x = 0; x < width;) { - - dataByte = pcx.data.get(); - - if ((dataByte & 0xC0) == 0xC0) { - runLength = dataByte & 0x3F; - dataByte = pcx.data.get(); - // write runLength pixel - while (runLength-- > 0) { - pix[count++] = dataByte; - x++; - } - } else { - // write one pixel - pix[count++] = dataByte; - x++; - } - } - } - return pix; - } - - protected Throwable gotoBreakOut = new Throwable(); - - protected Throwable gotoDone = gotoBreakOut; - - // /* - // ========================================================= - // - // TARGA LOADING - // - // ========================================================= - // */ - - - /** - * LoadTGA - */ - protected byte[] LoadTGA(String name, Dimension dim) { - int columns, rows, numPixels; - int pixbuf; // index into pic - int row, column; - byte[] raw; - ByteBuffer buf_p; - qfiles.tga_t targa_header; - byte[] pic = null; - - // - // load the file - // - raw = FS.LoadFile(name); - - if (raw == null) { - VID.Printf(Defines.PRINT_DEVELOPER, "Bad tga file " + name + '\n'); - return null; - } - - targa_header = new qfiles.tga_t(raw); - - if (targa_header.image_type != 2 && targa_header.image_type != 10) - Com.Error(Defines.ERR_DROP, "LoadTGA: Only type 2 and 10 targa RGB images supported\n"); - - if (targa_header.colormap_type != 0 - || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24)) - Com.Error(Defines.ERR_DROP, "LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n"); - - columns = targa_header.width; - rows = targa_header.height; - numPixels = columns * rows; - - if (dim != null) { - dim.width = columns; - dim.height = rows; - } - - pic = new byte[numPixels * 4]; // targa_rgba; - - if (targa_header.id_length != 0) - targa_header.data.position(targa_header.id_length); // skip TARGA - // image comment - - buf_p = targa_header.data; - - byte red, green, blue, alphabyte; - red = green = blue = alphabyte = 0; - int packetHeader, packetSize, j; - - if (targa_header.image_type == 2) { // Uncompressed, RGB images - for (row = rows - 1; row >= 0; row--) { - - pixbuf = row * columns * 4; - - for (column = 0; column < columns; column++) { - switch (targa_header.pixel_size) { - case 24: - - blue = buf_p.get(); - green = buf_p.get(); - red = buf_p.get(); - pic[pixbuf++] = red; - pic[pixbuf++] = green; - pic[pixbuf++] = blue; - pic[pixbuf++] = (byte) 255; - break; - case 32: - blue = buf_p.get(); - green = buf_p.get(); - red = buf_p.get(); - alphabyte = buf_p.get(); - pic[pixbuf++] = red; - pic[pixbuf++] = green; - pic[pixbuf++] = blue; - pic[pixbuf++] = alphabyte; - break; - } - } - } - } else if (targa_header.image_type == 10) { // Runlength encoded RGB images - for (row = rows - 1; row >= 0; row--) { - - pixbuf = row * columns * 4; - try { - - for (column = 0; column < columns;) { - - packetHeader = buf_p.get() & 0xFF; - packetSize = 1 + (packetHeader & 0x7f); - - if ((packetHeader & 0x80) != 0) { // run-length packet - switch (targa_header.pixel_size) { - case 24: - blue = buf_p.get(); - green = buf_p.get(); - red = buf_p.get(); - alphabyte = (byte) 255; - break; - case 32: - blue = buf_p.get(); - green = buf_p.get(); - red = buf_p.get(); - alphabyte = buf_p.get(); - break; - } - - for (j = 0; j < packetSize; j++) { - pic[pixbuf++] = red; - pic[pixbuf++] = green; - pic[pixbuf++] = blue; - pic[pixbuf++] = alphabyte; - column++; - if (column == columns) { // run spans across rows - column = 0; - if (row > 0) - row--; - else - // goto label breakOut; - throw gotoBreakOut; - - pixbuf = row * columns * 4; - } - } - } else { // non run-length packet - for (j = 0; j < packetSize; j++) { - switch (targa_header.pixel_size) { - case 24: - blue = buf_p.get(); - green = buf_p.get(); - red = buf_p.get(); - pic[pixbuf++] = red; - pic[pixbuf++] = green; - pic[pixbuf++] = blue; - pic[pixbuf++] = (byte) 255; - break; - case 32: - blue = buf_p.get(); - green = buf_p.get(); - red = buf_p.get(); - alphabyte = buf_p.get(); - pic[pixbuf++] = red; - pic[pixbuf++] = green; - pic[pixbuf++] = blue; - pic[pixbuf++] = alphabyte; - break; - } - column++; - if (column == columns) { // pixel packet run - // spans across rows - column = 0; - if (row > 0) - row--; - else - // goto label breakOut; - throw gotoBreakOut; - - pixbuf = row * columns * 4; - } - } - } - } - } catch (Throwable e) { - // label breakOut: - } - } - } - return pic; - } - - /** - * GL_LoadWal - */ - protected image_t GL_LoadWal(String name) { - - image_t image = null; - - byte[] raw = FS.LoadFile(name); - if (raw == null) { - VID.Printf(Defines.PRINT_ALL, "GL_FindImage: can't load " + name - + '\n'); - return r_notexture; - } - - qfiles.miptex_t mt = new qfiles.miptex_t(raw); - - byte[] pix = new byte[mt.width * mt.height]; - System.arraycopy(raw, mt.offsets[0], pix, 0, pix.length); - - image = GL_LoadPic(name, pix, mt.width, mt.height, it_wall, 8); - - return image; - } - - /** - * GL_FindImage - * - * Finds or loads the given image. - */ - protected image_t GL_FindImage(String name, int type) { - image_t image = null; - - // TODO loest das grossschreibungs problem - // name = name.toLowerCase(); - // bughack for bad strings (fuck \0) - // int index = name.indexOf('\0'); - // if (index != -1) - // name = name.substring(0, index); - - if (name == null || name.length() < 5) - return null; - - // look for it - for (int i = 0; i < numgltextures; i++) { - image = gltextures[i]; - if (name.equals(image.name)) { - image.registration_sequence = registration_sequence; - return image; - } - } - - // - // load the pic from disk - // - image = null; - byte[] pic = null; - Dimension dim = new Dimension(); - - if (name.endsWith(".pcx")) { - - pic = LoadPCX(name, null, dim); - if (pic == null) - return null; - image = GL_LoadPic(name, pic, dim.width, dim.height, type, 8); - - } else if (name.endsWith(".wal")) { - - image = GL_LoadWal(name); - - } else if (name.endsWith(".tga")) { - - pic = LoadTGA(name, dim); - - if (pic == null) - return null; - - image = GL_LoadPic(name, pic, dim.width, dim.height, type, 32); - - } - - return image; - } - - /** - * R_RegisterSkin - */ - protected image_t R_RegisterSkin(String name) { - return GL_FindImage(name, it_skin); - } - - /** - * Draw_GetPalettes - */ - protected void Draw_GetPalette() { - int r, g, b; - byte[] pic; - byte[][] palette = new byte[1][]; // new byte[768]; - - // get the palette - pic = LoadPCX("pics/colormap.pcx", palette, new Dimension()); - - if (pic == null || palette[0] == null || palette[0].length != 768) - Com.Error(Defines.ERR_FATAL, "Couldn't load pics/colormap.pcx"); - - byte[] pal = palette[0]; - - int j = 0; - for (int i = 0; i < 256; i++) { - r = pal[j++] & 0xFF; - g = pal[j++] & 0xFF; - b = pal[j++] & 0xFF; - - d_8to24table[i] = (255 << 24) | (b << 16) | (g << 8) | (r << 0); - } - - d_8to24table[255] &= 0x00FFFFFF; // 255 is transparent - - particle_t.setColorPalette(d_8to24table); - } - - /** - * GL_BuildPalettedTexture. - */ - protected void GL_BuildPalettedTexture(byte[] paletted_texture, int[] scaled, - int scaled_width, int scaled_height) { - - int r, g, b, c; - int size = scaled_width * scaled_height; - - for (int i = 0; i < size; i++) { - - r = (scaled[i] >> 3) & 31; - g = (scaled[i] >> 10) & 63; - b = (scaled[i] >> 19) & 31; - - c = r | (g << 5) | (b << 11); - - paletted_texture[i] = gl_state.d_16to8table[c]; - } - } - - protected void GL_Bind(int texnum) { - - if ((gl_nobind.value != 0) && (draw_chars != null)) { - // performance evaluation option - texnum = draw_chars.texnum; - } - if (gl_state.currenttextures[gl_state.currenttmu] == texnum) - return; - - gl_state.currenttextures[gl_state.currenttmu] = texnum; - ggl.glBindTexture(ggl.GL_TEXTURE_2D, texnum); - } - - int scrap_uploads = 0; - - - protected void Scrap_Upload() { - scrap_uploads++; - GL_Bind(TEXNUM_SCRAPS); - GL_Upload8(scrap_texels[0], BLOCK_WIDTH, BLOCK_HEIGHT, false, false); - scrap_dirty = false; - } - - - protected void GL_MBind(int target, int texnum) { - GL_SelectTexture(target); - if (target == GL_TEXTURE0) { - if (gl_state.currenttextures[0] == texnum) - return; - } else { - if (gl_state.currenttextures[1] == texnum) - return; - } - GL_Bind(texnum); - } -} diff --git a/src/jake2/render/common/Light.java b/src/jake2/render/common/Light.java deleted file mode 100644 index 5781975..0000000 --- a/src/jake2/render/common/Light.java +++ /dev/null @@ -1,685 +0,0 @@ -/* -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. - -*/ - -// Created on 20.08.2006 by RST. - -// $Id: Light.java,v 1.1 2006-10-31 13:06:32 salomo Exp $ - -package jake2.render.common; - - -import java.nio.ByteBuffer; -import java.nio.IntBuffer; -import java.util.Arrays; - -import jake2.*; -import jake2.client.*; -import jake2.game.*; -import jake2.qcommon.*; -import jake2.render.*; -import jake2.server.*; -import jake2.util.Math3D; -import jake2.util.Vec3Cache; - -public abstract class Light extends Warp { - - protected float[] pointcolor = { 0, 0, 0 }; // vec3_t - - protected cplane_t lightplane; // used as shadow plane - - protected float[] lightspot = { 0, 0, 0 }; // vec3_t - - protected float[] s_blocklights = new float[34 * 34 * 3]; - - protected int r_dlightframecount; - - protected final float[] impact = { 0, 0, 0 }; - - - public static final int DLIGHT_CUTOFF = 64; - - /** - * R_AddDynamicLights - */ - protected void R_AddDynamicLights(msurface_t surf) { - int sd, td; - float fdist, frad, fminlight; - int s, t; - dlight_t dl; - float[] pfBL; - float fsacc, ftacc; - - int smax = (surf.extents[0] >> 4) + 1; - int tmax = (surf.extents[1] >> 4) + 1; - mtexinfo_t tex = surf.texinfo; - - float local0, local1; - for (int lnum = 0; lnum < r_newrefdef.num_dlights; lnum++) { - if ((surf.dlightbits & (1 << lnum)) == 0) - continue; // not lit by this light - - dl = r_newrefdef.dlights[lnum]; - frad = dl.intensity; - fdist = Math3D.DotProduct(dl.origin, surf.plane.normal) - - surf.plane.dist; - frad -= Math.abs(fdist); - // rad is now the highest intensity on the plane - - fminlight = DLIGHT_CUTOFF; // FIXME: make configurable? - if (frad < fminlight) - continue; - fminlight = frad - fminlight; - - for (int i = 0; i < 3; i++) { - impact[i] = dl.origin[i] - surf.plane.normal[i] * fdist; - } - - local0 = Math3D.DotProduct(impact, tex.vecs[0]) + tex.vecs[0][3] - - surf.texturemins[0]; - local1 = Math3D.DotProduct(impact, tex.vecs[1]) + tex.vecs[1][3] - - surf.texturemins[1]; - - pfBL = s_blocklights; - int pfBLindex = 0; - for (t = 0, ftacc = 0; t < tmax; t++, ftacc += 16) { - td = (int) (local1 - ftacc); - if (td < 0) - td = -td; - - for (s = 0, fsacc = 0; s < smax; s++, fsacc += 16, pfBLindex += 3) { - sd = (int) (local0 - fsacc); - - if (sd < 0) - sd = -sd; - - if (sd > td) - fdist = sd + (td >> 1); - else - fdist = td + (sd >> 1); - - if (fdist < fminlight) { - pfBL[pfBLindex + 0] += (frad - fdist) * dl.color[0]; - pfBL[pfBLindex + 1] += (frad - fdist) * dl.color[1]; - pfBL[pfBLindex + 2] += (frad - fdist) * dl.color[2]; - } - } - } - } - } - - // replaces the goto jump - private Throwable gotoStore = new Throwable(); - - /** - * R_BuildLightMap - * - * Combine and scale multiple lightmaps into the floating format in - * blocklights - */ - - protected void R_BuildLightMap(msurface_t surf, IntBuffer dest, int stride) { - int r, g, b, a, max; - int i, j; - int nummaps; - float[] bl; - // lightstyle_t style; - - if ((surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 - | Defines.SURF_TRANS66 | Defines.SURF_WARP)) != 0) - Com.Error(Defines.ERR_DROP, - "R_BuildLightMap called for non-lit surface"); - - int smax = (surf.extents[0] >> 4) + 1; - int tmax = (surf.extents[1] >> 4) + 1; - int size = smax * tmax; - if (size > ((s_blocklights.length * Defines.SIZE_OF_FLOAT) >> 4)) - Com.Error(Defines.ERR_DROP, "Bad s_blocklights size"); - - try { - // set to full bright if no light data - if (surf.samples == null) { - - for (i = 0; i < size * 3; i++) - s_blocklights[i] = 255; - - // goto store; - throw gotoStore; - } - - // count the # of maps - for (nummaps = 0; nummaps < Defines.MAXLIGHTMAPS - && surf.styles[nummaps] != (byte) 255; nummaps++); - - ByteBuffer lightmap = surf.samples; - int lightmapIndex = 0; - - // add all the lightmaps - float scale0; - float scale1; - float scale2; - if (nummaps == 1) { - int maps; - - for (maps = 0; maps < Defines.MAXLIGHTMAPS - && surf.styles[maps] != (byte) 255; maps++) { - bl = s_blocklights; - int blp = 0; - - // for (i = 0; i < 3; i++) - // scale[i] = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i]; - - scale0 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[0]; - scale1 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[1]; - scale2 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[2]; - - if (scale0 == 1.0F && scale1 == 1.0F && scale2 == 1.0F) { - for (i = 0; i < size; i++) { - bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; - bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; - bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; - } - } else { - for (i = 0; i < size; i++) { - bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale0; - bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale1; - bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) * scale2; - } - } - // lightmap += size*3; // skip to next lightmap - } - } else { - int maps; - - Arrays.fill(s_blocklights, 0, size * 3, 0.0f); - - for (maps = 0; maps < Defines.MAXLIGHTMAPS - && surf.styles[maps] != (byte) 255; maps++) { - bl = s_blocklights; - int blp = 0; - - // for (i = 0; i < 3; i++) - // scale[i] = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i]; - scale0 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[0]; - scale1 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[1]; - scale2 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[2]; - - if (scale0 == 1.0F && scale1 == 1.0F && scale2 == 1.0F) { - for (i = 0; i < size; i++) { - bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; - bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; - bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; - } - } else { - for (i = 0; i < size; i++) { - bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale0; - bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale1; - bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) * scale2; - } - } - // lightmap += size*3; // skip to next lightmap - } - } - - // add all the dynamic lights - if (surf.dlightframe == r_framecount) - R_AddDynamicLights(surf); - - // label store: - } catch (Throwable store) { - } - - // put into texture format - stride -= smax; - bl = s_blocklights; - int blp = 0; - - int monolightmap = gl_monolightmap.string.charAt(0); - - int destp = 0; - - if (monolightmap == '0') { - for (i = 0; i < tmax; i++, destp += stride) { - // dest.position(destp); - - for (j = 0; j < smax; j++) { - - r = (int) bl[blp++]; - g = (int) bl[blp++]; - b = (int) bl[blp++]; - - // catch negative lights - if (r < 0) - r = 0; - if (g < 0) - g = 0; - if (b < 0) - b = 0; - - /* - * * determine the brightest of the three color components - */ - if (r > g) - max = r; - else - max = g; - if (b > max) - max = b; - - /* - * * alpha is ONLY used for the mono lightmap case. For this - * reason * we set it to the brightest of the color - * components so that * things don't get too dim. - */ - a = max; - - /* - * * rescale all the color components if the intensity of - * the greatest * channel exceeds 1.0 - */ - if (max > 255) { - float t = 255.0F / max; - - r = (int) (r * t); - g = (int) (g * t); - b = (int) (b * t); - a = (int) (a * t); - } - // r &= 0xFF; g &= 0xFF; b &= 0xFF; a &= 0xFF; - dest.put(destp++, (a << 24) | (b << 16) | (g << 8) | r); - } - } - } else { - for (i = 0; i < tmax; i++, destp += stride) { - // dest.position(destp); - - for (j = 0; j < smax; j++) { - - r = (int) bl[blp++]; - g = (int) bl[blp++]; - b = (int) bl[blp++]; - - // catch negative lights - if (r < 0) - r = 0; - if (g < 0) - g = 0; - if (b < 0) - b = 0; - - /* - * * determine the brightest of the three color components - */ - if (r > g) - max = r; - else - max = g; - if (b > max) - max = b; - - /* - * * alpha is ONLY used for the mono lightmap case. For this - * reason * we set it to the brightest of the color - * components so that * things don't get too dim. - */ - a = max; - - /* - * * rescale all the color components if the intensity of - * the greatest * channel exceeds 1.0 - */ - if (max > 255) { - float t = 255.0F / max; - - r = (int) (r * t); - g = (int) (g * t); - b = (int) (b * t); - a = (int) (a * t); - } - - /* - * * So if we are doing alpha lightmaps we need to set the - * R, G, and B * components to 0 and we need to set alpha to - * 1-alpha. - */ - switch (monolightmap) { - case 'L': - case 'I': - r = a; - g = b = 0; - break; - case 'C': - // try faking colored lighting - a = 255 - ((r + g + b) / 3); - float af = a / 255.0f; - r *= af; - g *= af; - b *= af; - break; - case 'A': - default: - r = g = b = 0; - a = 255 - a; - break; - } - // r &= 0xFF; g &= 0xFF; b &= 0xFF; a &= 0xFF; - dest.put(destp++, (a << 24) | (b << 16) | (g << 8) | r); - } - } - } - } - - - // stack variable - private final float[] end = { 0, 0, 0 }; - - /** - * R_LightPoint - */ - protected void R_LightPoint(float[] p, float[] color) { - assert (p.length == 3) : "vec3_t bug"; - assert (color.length == 3) : "rgb bug"; - - if (r_worldmodel.lightdata == null) { - color[0] = color[1] = color[2] = 1.0f; - return; - } - - end[0] = p[0]; - end[1] = p[1]; - end[2] = p[2] - 2048; - - float r = RecursiveLightPoint(r_worldmodel.nodes[0], p, end); - - if (r == -1) { - Math3D.VectorCopy(Globals.vec3_origin, color); - } else { - Math3D.VectorCopy(pointcolor, color); - } - - // - // add dynamic lights - // - dlight_t dl; - float add; - for (int lnum = 0; lnum < r_newrefdef.num_dlights; lnum++) { - dl = r_newrefdef.dlights[lnum]; - - Math3D.VectorSubtract(currententity.origin, dl.origin, end); - add = dl.intensity - Math3D.VectorLength(end); - add *= (1.0f / 256); - if (add > 0) { - Math3D.VectorMA(color, add, dl.color, color); - } - } - Math3D.VectorScale(color, gl_modulate.value, color); - } - - /** - * RecursiveLightPoint - * - * @param node - * @param start - * @param end - * @return - */ - protected int RecursiveLightPoint(mnode_t node, float[] start, float[] end) { - if (node.contents != -1) - return -1; // didn't hit anything - - // calculate mid point - - // FIXME: optimize for axial - cplane_t plane = node.plane; - float front = Math3D.DotProduct(start, plane.normal) - plane.dist; - float back = Math3D.DotProduct(end, plane.normal) - plane.dist; - boolean side = (front < 0); - int sideIndex = (side) ? 1 : 0; - - if ((back < 0) == side) - return RecursiveLightPoint(node.children[sideIndex], start, end); - - float frac = front / (front - back); - float[] mid = Vec3Cache.get(); - mid[0] = start[0] + (end[0] - start[0]) * frac; - mid[1] = start[1] + (end[1] - start[1]) * frac; - mid[2] = start[2] + (end[2] - start[2]) * frac; - - // go down front side - int r = RecursiveLightPoint(node.children[sideIndex], start, mid); - if (r >= 0) { - Vec3Cache.release(); // mid - return r; // hit something - } - - if ((back < 0) == side) { - Vec3Cache.release(); // mid - return -1; // didn't hit anuthing - } - - // check for impact on this node - Math3D.VectorCopy(mid, lightspot); - lightplane = plane; - int surfIndex = node.firstsurface; - - msurface_t surf; - int s, t, ds, dt; - mtexinfo_t tex; - ByteBuffer lightmap; - int maps; - for (int i = 0; i < node.numsurfaces; i++, surfIndex++) { - surf = r_worldmodel.surfaces[surfIndex]; - - if ((surf.flags & (Defines.SURF_DRAWTURB | Defines.SURF_DRAWSKY)) != 0) - continue; // no lightmaps - - tex = surf.texinfo; - - s = (int) (Math3D.DotProduct(mid, tex.vecs[0]) + tex.vecs[0][3]); - t = (int) (Math3D.DotProduct(mid, tex.vecs[1]) + tex.vecs[1][3]); - - if (s < surf.texturemins[0] || t < surf.texturemins[1]) - continue; - - ds = s - surf.texturemins[0]; - dt = t - surf.texturemins[1]; - - if (ds > surf.extents[0] || dt > surf.extents[1]) - continue; - - if (surf.samples == null) - return 0; - - ds >>= 4; - dt >>= 4; - - lightmap = surf.samples; - int lightmapIndex = 0; - - Math3D.VectorCopy(Globals.vec3_origin, pointcolor); - if (lightmap != null) { - float[] rgb; - lightmapIndex += 3 * (dt * ((surf.extents[0] >> 4) + 1) + ds); - - float scale0, scale1, scale2; - for (maps = 0; maps < Defines.MAXLIGHTMAPS - && surf.styles[maps] != (byte) 255; maps++) { - rgb = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb; - scale0 = gl_modulate.value * rgb[0]; - scale1 = gl_modulate.value * rgb[1]; - scale2 = gl_modulate.value * rgb[2]; - - pointcolor[0] += (lightmap.get(lightmapIndex + 0) & 0xFF) - * scale0 * (1.0f / 255); - pointcolor[1] += (lightmap.get(lightmapIndex + 1) & 0xFF) - * scale1 * (1.0f / 255); - pointcolor[2] += (lightmap.get(lightmapIndex + 2) & 0xFF) - * scale2 * (1.0f / 255); - lightmapIndex += 3 * ((surf.extents[0] >> 4) + 1) - * ((surf.extents[1] >> 4) + 1); - } - } - Vec3Cache.release(); // mid - return 1; - } - - // go down back side - r = RecursiveLightPoint(node.children[1 - sideIndex], mid, end); - Vec3Cache.release(); // mid - return r; - } - - /** - * R_MarkLights - */ - protected void R_MarkLights(dlight_t light, int bit, mnode_t node) { - if (node.contents != -1) - return; - - cplane_t splitplane = node.plane; - float dist = Math3D.DotProduct(light.origin, splitplane.normal) - - splitplane.dist; - - if (dist > light.intensity - DLIGHT_CUTOFF) { - R_MarkLights(light, bit, node.children[0]); - return; - } - if (dist < -light.intensity + DLIGHT_CUTOFF) { - R_MarkLights(light, bit, node.children[1]); - return; - } - - // mark the polygons - msurface_t surf; - int sidebit; - for (int i = 0; i < node.numsurfaces; i++) { - - surf = r_worldmodel.surfaces[node.firstsurface + i]; - - /* - * cwei bugfix for dlight behind the walls - */ - dist = Math3D.DotProduct(light.origin, surf.plane.normal) - - surf.plane.dist; - sidebit = (dist >= 0) ? 0 : Defines.SURF_PLANEBACK; - if ((surf.flags & Defines.SURF_PLANEBACK) != sidebit) - continue; - /* - * cwei bugfix end - */ - - if (surf.dlightframe != r_dlightframecount) { - surf.dlightbits = 0; - surf.dlightframe = r_dlightframecount; - } - surf.dlightbits |= bit; - } - - R_MarkLights(light, bit, node.children[0]); - R_MarkLights(light, bit, node.children[1]); - } - - /** - * R_SetCacheState - */ - protected void R_SetCacheState(msurface_t surf) { - for (int maps = 0; maps < Defines.MAXLIGHTMAPS - && surf.styles[maps] != (byte) 255; maps++) { - surf.cached_light[maps] = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].white; - } - } - - - /** - * R_PushDlights - */ - protected void R_PushDlights() { - if (gl_flashblend.value != 0) - return; - - r_dlightframecount = r_framecount + 1; // because the count hasn't - // advanced yet for this frame - dlight_t l; - for (int i = 0; i < r_newrefdef.num_dlights; i++) { - l = r_newrefdef.dlights[i]; - R_MarkLights(l, 1 << i, r_worldmodel.nodes[0]); - } - } - - - /* - * ============================================================================= - * - * DYNAMIC LIGHTS BLEND RENDERING - * - * ============================================================================= - */ - - void R_RenderDlight(dlight_t light) { - float rad = light.intensity * 0.35f; - float[] v = Vec3Cache.get(); - Math3D.VectorSubtract(light.origin, r_origin, v); - - ggl.glBegin(ggl.GL_TRIANGLE_FAN); - ggl.glColor3f(light.color[0] * 0.2f, light.color[1] * 0.2f, - light.color[2] * 0.2f); - for (int i = 0; i < 3; i++) - v[i] = light.origin[i] - vpn[i] * rad; - - ggl.glVertex3f(v[0], v[1], v[2]); - ggl.glColor3f(0, 0, 0); - float a; - for (int i = 16; i >= 0; i--) { - a = (float) (i / 16.0f * Math.PI * 2); - for (int j = 0; j < 3; j++) - v[j] = (float) (light.origin[j] + vright[j] * Math.cos(a) * rad + vup[j] - * Math.sin(a) * rad); - ggl.glVertex3f(v[0], v[1], v[2]); - } - ggl.glEnd(); - Vec3Cache.release(); - } - - - /** - * ============= R_RenderDlights ============= - */ - public void R_RenderDlights() { - if (gl_flashblend.value == 0) - return; - - r_dlightframecount = r_framecount + 1; // because the count hasn't - // advanced yet for this frame - ggl.glDepthMask(false); - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glShadeModel(ggl.GL_SMOOTH); - ggl.glDisable(ggl.GL_BLEND); - ggl.glBlendFunc(ggl.GL_ONE, ggl.GL_ONE); - - for (int i = 0; i < r_newrefdef.num_dlights; i++) { - R_RenderDlight(r_newrefdef.dlights[i]); - } - - ggl.glColor3f(1, 1, 1); - ggl.glDisable(ggl.GL_BLEND); - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glBlendFunc(ggl.GL_SRC_ALPHA, ggl.GL_ONE_MINUS_SRC_ALPHA); - ggl.glDepthMask(true); - } -} diff --git a/src/jake2/render/common/Main.java b/src/jake2/render/common/Main.java deleted file mode 100644 index a4deeb7..0000000 --- a/src/jake2/render/common/Main.java +++ /dev/null @@ -1,1181 +0,0 @@ -/* -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. - -*/ - -// Created on 19.08.2006 by RST. - -// $Id: Main.java,v 1.1 2006-10-31 13:06:32 salomo Exp $ - -package jake2.render.common; - -import jake2.Defines; -import jake2.Globals; -import jake2.client.*; -import jake2.game.*; -import jake2.qcommon.*; -import jake2.render.*; -import jake2.util.Math3D; -import jake2.util.Vargs; - -import java.awt.Dimension; -import java.nio.FloatBuffer; -import java.nio.IntBuffer; - -public abstract class Main extends Base { - - // ================= - // abstract methods - // ================= - protected abstract void Draw_GetPalette(); - protected abstract void Draw_InitLocal(); - - protected abstract boolean GL_Upload32(int[] data, int width, int height, boolean mipmap); - protected abstract boolean GL_Upload8(byte[] data, int width, int height, boolean mipmap, boolean is_sky); - protected abstract void GL_Bind(int texnum); - protected abstract void GL_SelectTexture(int target); - protected abstract void GL_ImageList_f(); - protected abstract void GL_InitImages(); - protected abstract void GL_TextureAlphaMode(String name); - protected abstract void GL_TextureSolidMode(String name); - protected abstract void GL_ScreenShot_f(); - protected abstract void GL_SetTexturePalette(int[] palette); - protected abstract void GL_Strings_f(); - protected abstract void GL_SetDefaultState(); - protected abstract void GL_ShutdownImages(); - protected abstract void GL_TexEnv(int mode); - protected abstract void GL_TextureMode(String string); - protected abstract void GL_UpdateSwapInterval(); - protected abstract image_t GL_FindImage(String name, int type); - protected abstract void GL_FreeUnusedImages(); - protected abstract void GL_EndBuildingLightmaps(); - protected abstract void GL_BeginBuildingLightmaps(model_t model); - protected abstract void GL_BuildPolygonFromSurface(msurface_t surface); - protected abstract void GL_CreateSurfaceLightmap(msurface_t survace); - protected abstract void GL_SubdivideSurface(msurface_t survace); - - - protected abstract void R_InitParticleTexture(); // MIsc.java - protected abstract void R_DrawAliasModel(entity_t e); // Mesh.java - protected abstract void R_DrawBrushModel(entity_t e); // Surf.java - protected abstract void R_LightPoint(float[] p, float[] color); - protected abstract void R_PushDlights(); - protected abstract void R_MarkLeaves(); - protected abstract void R_DrawWorld(); - protected abstract void R_RenderDlights(); - protected abstract void R_DrawAlphaSurfaces(); - protected abstract void R_SetupFrame(); - - protected abstract void Mod_Modellist_f(); - protected abstract void Mod_FreeAll(); - protected abstract void GLimp_Finish(); - protected abstract void GLimp_Shutdown(); - protected abstract int GLimp_SetMode(Dimension dim, int mode, boolean fullscreen); - - protected static int[] d_8to24table = new int[256]; - - protected int c_visible_lightmaps; - - protected int c_visible_textures; - - protected int registration_sequence; - - // this a hack for function pointer test - // default disabled - protected boolean qglColorTableEXT = true; - - protected boolean qglActiveTextureARB = false; - - protected boolean qglPointParameterfEXT = false; - - protected boolean qglLockArraysEXT = false; - - protected boolean qwglSwapIntervalEXT = false; - - protected static final int NUM_BEAM_SEGS = 6; - - protected float[][] start_points = new float[NUM_BEAM_SEGS][3]; - - // array of vec3_t - protected float[][] end_points = new float[NUM_BEAM_SEGS][3]; // array of vec3_t - - /* - * ==================================================================== - * - * from gl_rmain.c - * - * ==================================================================== - */ - - protected model_t r_worldmodel; - - protected float gldepthmin, gldepthmax; - - protected glconfig_t gl_config = new glconfig_t(); - - protected glstate_t gl_state = new glstate_t(); - - protected image_t r_notexture; // use for bad textures - - protected image_t r_particletexture; // little dot for particles - - protected entity_t currententity; - - protected model_t currentmodel; - - protected cplane_t frustum[] = { new cplane_t(), new cplane_t(), new cplane_t(), - new cplane_t() }; - - protected int r_visframecount; // bumped when going to a new PVS - - protected int r_framecount; // used for dlight push checking - - protected int c_brush_polys, c_alias_polys; - - protected float v_blend[] = { 0, 0, 0, 0 }; // final blending color - - // - // view origin - // - protected float[] vup = { 0, 0, 0 }; - - protected float[] vpn = { 0, 0, 0 }; - - protected float[] vright = { 0, 0, 0 }; - - protected float[] r_origin = { 0, 0, 0 }; - - protected float r_world_matrix[] = new float[16]; - - protected float r_base_world_matrix[] = new float[16]; - - // - // screen size info - // - protected refdef_t r_newrefdef = new refdef_t(); - - protected int r_viewcluster, r_viewcluster2, r_oldviewcluster, r_oldviewcluster2; - - protected cvar_t r_norefresh; - - protected cvar_t r_drawentities; - - protected cvar_t r_drawworld; - - protected cvar_t r_speeds; - - protected cvar_t r_fullbright; - - protected cvar_t r_novis; - - protected cvar_t r_nocull; - - protected cvar_t r_lerpmodels; - - protected cvar_t r_lefthand; - - protected cvar_t r_lightlevel; - - protected cvar_t gl_nosubimage; - - protected cvar_t gl_allow_software; - - protected cvar_t gl_vertex_arrays; - - protected cvar_t gl_particle_min_size; - - protected cvar_t gl_particle_max_size; - - protected cvar_t gl_particle_size; - - protected cvar_t gl_particle_att_a; - - protected cvar_t gl_particle_att_b; - - protected cvar_t gl_particle_att_c; - - protected cvar_t gl_ext_swapinterval; - - protected cvar_t gl_ext_palettedtexture; - - protected cvar_t gl_ext_multitexture; - - protected cvar_t gl_ext_pointparameters; - - protected cvar_t gl_ext_compiled_vertex_array; - - protected cvar_t gl_log; - - protected cvar_t gl_bitdepth; - - protected cvar_t gl_drawbuffer; - - protected cvar_t gl_driver; - - protected cvar_t gl_lightmap; - - protected cvar_t gl_shadows; - - protected cvar_t gl_mode; - - protected cvar_t gl_dynamic; - - protected cvar_t gl_monolightmap; - - protected cvar_t gl_modulate; - - protected cvar_t gl_nobind; - - protected cvar_t gl_round_down; - - protected cvar_t gl_picmip; - - protected cvar_t gl_skymip; - - protected cvar_t gl_showtris; - - protected cvar_t gl_ztrick; - - protected cvar_t gl_finish; - - protected cvar_t gl_clear; - - protected cvar_t gl_cull; - - protected cvar_t gl_polyblend; - - protected cvar_t gl_flashblend; - - protected cvar_t gl_playermip; - - protected cvar_t gl_saturatelighting; - - protected cvar_t gl_swapinterval; - - protected cvar_t gl_texturemode; - - protected cvar_t gl_texturealphamode; - - protected cvar_t gl_texturesolidmode; - - protected cvar_t gl_lockpvs; - - protected cvar_t gl_3dlabs_broken; - - protected cvar_t vid_gamma; - - protected cvar_t vid_ref; - - protected int[] r_rawpalette = new int[256]; - - protected float[] r_turbsin = new float[256]; - - protected int trickframe = 0; - - protected cvar_t vid_fullscreen; - - // window position on the screen - protected int window_xpos, window_ypos; - protected viddef_t vid = new viddef_t(); - - // enum rserr_t - protected static final int rserr_ok = 0; - protected static final int rserr_invalid_fullscreen = 1; - protected static final int rserr_invalid_mode = 2; - protected static final int rserr_unknown = 3; - - - /** - * R_Register - */ - protected void R_Register() { - r_lefthand = Cvar.Get("hand", "0", Globals.CVAR_USERINFO | Globals.CVAR_ARCHIVE); - r_norefresh = Cvar.Get("r_norefresh", "0", 0); - r_fullbright = Cvar.Get("r_fullbright", "0", 0); - r_drawentities = Cvar.Get("r_drawentities", "1", 0); - r_drawworld = Cvar.Get("r_drawworld", "1", 0); - r_novis = Cvar.Get("r_novis", "0", 0); - r_nocull = Cvar.Get("r_nocull", "0", 0); - r_lerpmodels = Cvar.Get("r_lerpmodels", "1", 0); - r_speeds = Cvar.Get("r_speeds", "0", 0); - - r_lightlevel = Cvar.Get("r_lightlevel", "1", 0); - - gl_nosubimage = Cvar.Get("gl_nosubimage", "0", 0); - gl_allow_software = Cvar.Get("gl_allow_software", "0", 0); - - gl_particle_min_size = Cvar.Get("gl_particle_min_size", "2", Globals.CVAR_ARCHIVE); - gl_particle_max_size = Cvar.Get("gl_particle_max_size", "40", Globals.CVAR_ARCHIVE); - gl_particle_size = Cvar.Get("gl_particle_size", "40", Globals.CVAR_ARCHIVE); - gl_particle_att_a = Cvar.Get("gl_particle_att_a", "0.01", Globals.CVAR_ARCHIVE); - gl_particle_att_b = Cvar.Get("gl_particle_att_b", "0.0", Globals.CVAR_ARCHIVE); - gl_particle_att_c = Cvar.Get("gl_particle_att_c", "0.01", Globals.CVAR_ARCHIVE); - - gl_modulate = Cvar.Get("gl_modulate", "1.5", Globals.CVAR_ARCHIVE); - gl_log = Cvar.Get("gl_log", "0", 0); - gl_bitdepth = Cvar.Get("gl_bitdepth", "0", 0); - gl_mode = Cvar.Get("gl_mode", "3", Globals.CVAR_ARCHIVE); // 640x480 - gl_lightmap = Cvar.Get("gl_lightmap", "0", 0); - gl_shadows = Cvar.Get("gl_shadows", "0", Globals.CVAR_ARCHIVE); - gl_dynamic = Cvar.Get("gl_dynamic", "1", 0); - gl_nobind = Cvar.Get("gl_nobind", "0", 0); - gl_round_down = Cvar.Get("gl_round_down", "1", 0); - gl_picmip = Cvar.Get("gl_picmip", "0", 0); - gl_skymip = Cvar.Get("gl_skymip", "0", 0); - gl_showtris = Cvar.Get("gl_showtris", "0", 0); - gl_ztrick = Cvar.Get("gl_ztrick", "0", 0); - gl_finish = Cvar.Get("gl_finish", "0", Globals.CVAR_ARCHIVE); - gl_clear = Cvar.Get("gl_clear", "0", 0); - gl_cull = Cvar.Get("gl_cull", "1", 0); - gl_polyblend = Cvar.Get("gl_polyblend", "1", 0); - gl_flashblend = Cvar.Get("gl_flashblend", "0", 0); - gl_playermip = Cvar.Get("gl_playermip", "0", 0); - gl_monolightmap = Cvar.Get("gl_monolightmap", "0", 0); - gl_driver = Cvar.Get("gl_driver", "opengl32", Globals.CVAR_ARCHIVE); - gl_texturemode = Cvar.Get("gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST", Globals.CVAR_ARCHIVE); - gl_texturealphamode = Cvar.Get("gl_texturealphamode", "default", Globals.CVAR_ARCHIVE); - gl_texturesolidmode = Cvar.Get("gl_texturesolidmode", "default", Globals.CVAR_ARCHIVE); - gl_lockpvs = Cvar.Get("gl_lockpvs", "0", 0); - - gl_vertex_arrays = Cvar.Get("gl_vertex_arrays", "1", Globals.CVAR_ARCHIVE); - - gl_ext_swapinterval = Cvar.Get("gl_ext_swapinterval", "1", Globals.CVAR_ARCHIVE); - gl_ext_palettedtexture = Cvar.Get("gl_ext_palettedtexture", "0", Globals.CVAR_ARCHIVE); - gl_ext_multitexture = Cvar.Get("gl_ext_multitexture", "1", Globals.CVAR_ARCHIVE); - gl_ext_pointparameters = Cvar.Get("gl_ext_pointparameters", "1", Globals.CVAR_ARCHIVE); - gl_ext_compiled_vertex_array = Cvar.Get("gl_ext_compiled_vertex_array", "1", Globals.CVAR_ARCHIVE); - - gl_drawbuffer = Cvar.Get("gl_drawbuffer", "GL_BACK", 0); - gl_swapinterval = Cvar.Get("gl_swapinterval", "0", Globals.CVAR_ARCHIVE); - - gl_saturatelighting = Cvar.Get("gl_saturatelighting", "0", 0); - - gl_3dlabs_broken = Cvar.Get("gl_3dlabs_broken", "1", Globals.CVAR_ARCHIVE); - - vid_fullscreen = Cvar.Get("vid_fullscreen", "0", Globals.CVAR_ARCHIVE); - vid_gamma = Cvar.Get("vid_gamma", "1.0", Globals.CVAR_ARCHIVE); - vid_ref = Cvar.Get("vid_ref", "lwjgl", Globals.CVAR_ARCHIVE); - - Cmd.AddCommand("imagelist", new xcommand_t() { - public void execute() { - GL_ImageList_f(); - } - }); - - Cmd.AddCommand("screenshot", new xcommand_t() { - public void execute() { - GL_ScreenShot_f(); - } - }); - Cmd.AddCommand("modellist", new xcommand_t() { - public void execute() { - Mod_Modellist_f(); - } - }); - Cmd.AddCommand("gl_strings", new xcommand_t() { - public void execute() { - GL_Strings_f(); - } - }); - } - - - /** - * R_CullBox Returns true if the box is completely outside the frustum - */ - protected final boolean R_CullBox(float[] mins, float[] maxs) { - assert (mins.length == 3 && maxs.length == 3) : "vec3_t bug"; - - if (r_nocull.value != 0) - return false; - - for (int i = 0; i < 4; i++) { - if (Math3D.BoxOnPlaneSide(mins, maxs, frustum[i]) == 2) - return true; - } - return false; - } - - protected int SignbitsForPlane(cplane_t out) { - // for fast box on planeside test - int bits = 0; - for (int j = 0; j < 3; j++) { - if (out.normal[j] < 0) - bits |= (1 << j); - } - return bits; - } - - protected void R_SetFrustum() { - // rotate VPN right by FOV_X/2 degrees - Math3D.RotatePointAroundVector(frustum[0].normal, vup, vpn, -(90f - r_newrefdef.fov_x / 2f)); - // rotate VPN left by FOV_X/2 degrees - Math3D.RotatePointAroundVector(frustum[1].normal, vup, vpn, 90f - r_newrefdef.fov_x / 2f); - // rotate VPN up by FOV_X/2 degrees - Math3D.RotatePointAroundVector(frustum[2].normal, vright, vpn, 90f - r_newrefdef.fov_y / 2f); - // rotate VPN down by FOV_X/2 degrees - Math3D.RotatePointAroundVector(frustum[3].normal, vright, vpn, -(90f - r_newrefdef.fov_y / 2f)); - - for (int i = 0; i < 4; i++) { - frustum[i].type = Defines.PLANE_ANYZ; - frustum[i].dist = Math3D.DotProduct(r_origin, frustum[i].normal); - frustum[i].signbits = (byte) SignbitsForPlane(frustum[i]); - } - } - - protected abstract void GL_GetWorldMatrix(); - - /** - * R_SetupGL - */ - protected void R_SetupGL() { - - // - // set up viewport - // - int x = r_newrefdef.x; - int x2 = r_newrefdef.x + r_newrefdef.width; - int y = vid.height - r_newrefdef.y; - int y2 = vid.height - (r_newrefdef.y + r_newrefdef.height); - - int w = x2 - x; - int h = y - y2; - - ggl.glViewport(x, y2, w, h); - - // - // set up projection matrix - // - float screenaspect = (float) r_newrefdef.width / r_newrefdef.height; - ggl.glMatrixMode(ggl.GL_PROJECTION); - ggl.glLoadIdentity(); - MYgluPerspective(r_newrefdef.fov_y, screenaspect, 4, 4096); - - ggl.glCullFace(ggl.GL_FRONT); - - ggl.glMatrixMode(ggl.GL_MODELVIEW); - ggl.glLoadIdentity(); - - ggl.glRotatef(-90, 1, 0, 0); // put Z going up - ggl.glRotatef(90, 0, 0, 1); // put Z going up - ggl.glRotatef(-r_newrefdef.viewangles[2], 1, 0, 0); - ggl.glRotatef(-r_newrefdef.viewangles[0], 0, 1, 0); - ggl.glRotatef(-r_newrefdef.viewangles[1], 0, 0, 1); - ggl.glTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1], -r_newrefdef.vieworg[2]); - - GL_GetWorldMatrix(); - - // - // set drawing parms - // - if (gl_cull.value != 0.0f) - ggl.glEnable(ggl.GL_CULL_FACE); - else - ggl.glDisable(ggl.GL_CULL_FACE); - - ggl.glDisable(ggl.GL_BLEND); - ggl.glDisable(ggl.GL_ALPHA_TEST); - ggl.glEnable(ggl.GL_DEPTH_TEST); - } - - /** - * R_Clear. - */ - - protected void R_Clear() { - if (gl_ztrick.value != 0.0f) { - - if (gl_clear.value != 0.0f) { - ggl.glClear(ggl.GL_COLOR_BUFFER_BIT); - } - - trickframe++; - if ((trickframe & 1) != 0) { - gldepthmin = 0; - gldepthmax = 0.49999f; - ggl.glDepthFunc(ggl.GL_LEQUAL); - } - else { - gldepthmin = 1; - gldepthmax = 0.5f; - ggl.glDepthFunc(ggl.GL_GEQUAL); - } - } - else { - if (gl_clear.value != 0.0f) - ggl.glClear(ggl.GL_COLOR_BUFFER_BIT | ggl.GL_DEPTH_BUFFER_BIT); - else - ggl.glClear(ggl.GL_DEPTH_BUFFER_BIT); - - gldepthmin = 0; - gldepthmax = 1; - ggl.glDepthFunc(ggl.GL_LEQUAL); - } - ggl.glDepthRange(gldepthmin, gldepthmax); - } - - protected void R_SetGL2D() { - // set 2D virtual screen size - ggl.glViewport(0, 0, vid.width, vid.height); - ggl.glMatrixMode(ggl.GL_PROJECTION); - ggl.glLoadIdentity(); - ggl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999); - ggl.glMatrixMode(ggl.GL_MODELVIEW); - ggl.glLoadIdentity(); - ggl.glDisable(ggl.GL_DEPTH_TEST); - ggl.glDisable(ggl.GL_CULL_FACE); - ggl.glDisable(ggl.GL_BLEND); - ggl.glEnable(ggl.GL_ALPHA_TEST); - ggl.glColor4f(1, 1, 1, 1); - } - - - - /** - * R_RenderView. - * - * r_newrefdef must be set before the first call - */ - protected void R_RenderView(refdef_t fd) { - - if (r_norefresh.value != 0.0f) - return; - - r_newrefdef = fd; - - // included by cwei - if (r_newrefdef == null) { - Com.Error(Defines.ERR_DROP, "R_RenderView: refdef_t fd is null"); - } - - if (r_worldmodel == null - && (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) - Com.Error(Defines.ERR_DROP, "R_RenderView: NULL worldmodel"); - - if (r_speeds.value != 0.0f) { - c_brush_polys = 0; - c_alias_polys = 0; - } - - R_PushDlights(); - - if (gl_finish.value != 0.0f) - GLimp_Finish(); - - R_SetupFrame(); - - R_SetFrustum(); - - R_SetupGL(); - - R_MarkLeaves(); // done here so we know if we're in water - - R_DrawWorld(); - - R_DrawEntitiesOnList(); - - R_RenderDlights(); - - R_DrawParticles(); - - R_DrawAlphaSurfaces(); - - R_Flash(); - - if (r_speeds.value != 0.0f) { - VID.Printf(Defines.PRINT_ALL, "%4i wpoly %4i epoly %i tex %i lmaps\n", - new Vargs(4).add(c_brush_polys).add(c_alias_polys).add(c_visible_textures).add(c_visible_lightmaps)); - } - } - - /** - * R_RenderFrame. - * - */ - protected void R_RenderFrame(refdef_t fd) { - R_RenderView(fd); - R_SetLightLevel(); - R_SetGL2D(); - } - - - /** - * R_Shutdown - */ - protected void R_Shutdown() { - Cmd.RemoveCommand("modellist"); - Cmd.RemoveCommand("screenshot"); - Cmd.RemoveCommand("imagelist"); - Cmd.RemoveCommand("gl_strings"); - - Mod_FreeAll(); - - GL_ShutdownImages(); - - /* - * shut down OS specific OpenGL stuff like contexts, etc. - */ - GLimp_Shutdown(); - } - - // stack variable - private final float[] light = { 0, 0, 0 }; - - /** - * R_SetLightLevel - */ - void R_SetLightLevel() { - if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) - return; - - // save off light value for server to look at (BIG HACK!) - - R_LightPoint(r_newrefdef.vieworg, light); - - // pick the greatest component, which should be the same - // as the mono value returned by software - if (light[0] > light[1]) { - if (light[0] > light[2]) - r_lightlevel.value = 150 * light[0]; - else - r_lightlevel.value = 150 * light[2]; - } else { - if (light[1] > light[2]) - r_lightlevel.value = 150 * light[1]; - else - r_lightlevel.value = 150 * light[2]; - } - } - - /** - * R_Flash - */ - protected void R_Flash() { - R_PolyBlend(); - } - - - protected void MYgluPerspective(double fovy, double aspect, double zNear, double zFar) { - double xmin, xmax, ymin, ymax; - - ymax = zNear * Math.tan(fovy * Math.PI / 360.0); - ymin = -ymax; - - xmin = ymin * aspect; - xmax = ymax * aspect; - - xmin += - (2 * gl_state.camera_separation) / zNear; - xmax += - (2 * gl_state.camera_separation) / zNear; - - ggl.glFrustum(xmin, xmax, ymin, ymax, zNear, zFar); - } - - - /** - * R_SetMode - */ - protected boolean R_SetMode() { - boolean fullscreen = (vid_fullscreen.value > 0.0f); - - vid_fullscreen.modified = false; - gl_mode.modified = false; - - Dimension dim = new Dimension(vid.width, vid.height); - - int err; // enum rserr_t - if ((err = GLimp_SetMode(dim, (int) gl_mode.value, fullscreen)) == rserr_ok) { - gl_state.prev_mode = (int) gl_mode.value; - } else { - if (err == rserr_invalid_fullscreen) { - Cvar.SetValue("vid_fullscreen", 0); - vid_fullscreen.modified = false; - VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - fullscreen unavailable in this mode\n"); - if ((err = GLimp_SetMode(dim, (int) gl_mode.value, false)) == rserr_ok) - return true; - } else if (err == rserr_invalid_mode) { - Cvar.SetValue("gl_mode", gl_state.prev_mode); - gl_mode.modified = false; - VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - invalid mode\n"); - } - - // try setting it back to something safe - if ((err = GLimp_SetMode(dim, gl_state.prev_mode, false)) != rserr_ok) { - VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - could not revert to safe mode\n"); - return false; - } - } - return true; - } - - - /* - ============================================================= - - SPRITE MODELS - - ============================================================= - */ - - /* - ================= - R_DrawSpriteModel - - ================= - */ - void R_DrawSpriteModel(entity_t e) { - float alpha = 1.0F; - float[] point = { 0, 0, 0 }; - - 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) - ggl.glEnable(ggl.GL_BLEND); - - ggl.glColor4f(1, 1, 1, alpha); - - GL_Bind(currentmodel.skins[e.frame].texnum); - - GL_TexEnv(ggl.GL_MODULATE); - - if (alpha == 1.0) - ggl.glEnable(ggl.GL_ALPHA_TEST); - else - ggl.glDisable(ggl.GL_ALPHA_TEST); - - ggl.glBegin(ggl.GL_QUADS); - - ggl.glTexCoord2f(0, 1); - Math3D.VectorMA(e.origin, -frame.origin_y, vup, point); - Math3D.VectorMA(point, -frame.origin_x, vright, point); - ggl.glVertex3f(point[0], point[1], point[2]); - - ggl.glTexCoord2f(0, 0); - Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point); - Math3D.VectorMA(point, -frame.origin_x, vright, point); - ggl.glVertex3f(point[0], point[1], point[2]); - - ggl.glTexCoord2f(1, 0); - Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point); - Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point); - ggl.glVertex3f(point[0], point[1], point[2]); - - ggl.glTexCoord2f(1, 1); - Math3D.VectorMA(e.origin, -frame.origin_y, vup, point); - Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point); - ggl.glVertex3f(point[0], point[1], point[2]); - - ggl.glEnd(); - - ggl.glDisable(ggl.GL_ALPHA_TEST); - GL_TexEnv(ggl.GL_REPLACE); - - if (alpha != 1.0F) - ggl.glDisable(ggl.GL_BLEND); - - ggl.glColor4f(1, 1, 1, 1); - } - - /* - ============= - R_DrawNullModel - ============= - cwei :-) - */ - void R_DrawNullModel() { - float[] shadelight = { 0, 0, 0 }; - - if ((currententity.flags & Defines.RF_FULLBRIGHT) != 0) { - // cwei wollte blau: shadelight[0] = shadelight[1] = shadelight[2] = 1.0F; - shadelight[0] = shadelight[1] = shadelight[2] = 0.0F; - shadelight[2] = 0.8F; - } - else { - R_LightPoint(currententity.origin, shadelight); - } - - ggl.glPushMatrix(); - R_RotateForEntity(currententity); - - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glColor3f(shadelight[0], shadelight[1], shadelight[2]); - - // this replaces the TRIANGLE_FAN - //GlutWireCube(); - ggl.glBegin(ggl.GL_TRIANGLE_FAN); - ggl.glVertex3f(0, 0, -16); - int i; - for (i = 0; i <= 4; i++) { - ggl.glVertex3f((float) (16.0f * Math.cos(i * Math.PI / 2)), - (float) (16.0f * Math.sin(i * Math.PI / 2)), 0.0f); - } - ggl.glEnd(); - - ggl.glBegin(ggl.GL_TRIANGLE_FAN); - ggl.glVertex3f(0, 0, 16); - for (i = 4; i >= 0; i--) { - ggl.glVertex3f((float) (16.0f * Math.cos(i * Math.PI / 2)), - (float) (16.0f * Math.sin(i * Math.PI / 2)), 0.0f); - } - ggl.glEnd(); - - ggl.glColor3f(1, 1, 1); - ggl.glPopMatrix(); - ggl.glEnable(ggl.GL_TEXTURE_2D); - } - - protected abstract void R_RotateForEntity(entity_t currententity); - - - /** - * R_DrawEntitiesOnList - */ - protected void R_DrawEntitiesOnList() { - int i; - - if (r_drawentities.value == 0.0f) - return; - - // draw non-transparent first - for (i = 0; i < r_newrefdef.num_entities; i++) { - currententity = r_newrefdef.entities[i]; - if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) - continue; // solid - - if ((currententity.flags & Defines.RF_BEAM) != 0) { - R_DrawBeam(currententity); - } - else { - currentmodel = currententity.model; - if (currentmodel == null) { - R_DrawNullModel(); - continue; - } - switch (currentmodel.type) { - case Base.mod_alias: - R_DrawAliasModel(currententity); - break; - case Base.mod_brush: - R_DrawBrushModel(currententity); - break; - case Base.mod_sprite: - R_DrawSpriteModel(currententity); - break; - default: - Com.Error(Defines.ERR_DROP, "Bad modeltype:" + currentmodel.type); - break; - } - } - } - // draw transparent entities - // we could sort these if it ever becomes a problem... - ggl.glDepthMask(false); // no z writes - for (i = 0; i < r_newrefdef.num_entities; i++) { - currententity = r_newrefdef.entities[i]; - if ((currententity.flags & Defines.RF_TRANSLUCENT) == 0) - continue; // solid - - if ((currententity.flags & Defines.RF_BEAM) != 0) { - R_DrawBeam(currententity); - } - else { - currentmodel = currententity.model; - - if (currentmodel == null) { - R_DrawNullModel(); - continue; - } - switch (currentmodel.type) { - case Base.mod_alias: - R_DrawAliasModel(currententity); - break; - case Base.mod_brush: - R_DrawBrushModel(currententity); - break; - case Base.mod_sprite: - R_DrawSpriteModel(currententity); - break; - default : - //Com.Error(Defines.ERR_DROP, "Bad modeltype"); - //this can happen sometimes because of a threading issue with jogl/lwjgl? - //the fatal error was changed to a graceful return. - ggl.glDepthMask(true); - return; - //break; - } - } - } - ggl.glDepthMask(true); // back to writing - } - - /* - ** GL_DrawParticles - ** - */ - void GL_DrawParticles(int num_particles) { - float[] up = { 0, 0, 0 }; - float[] right = { 0, 0, 0 }; - float scale; - int color; - - float origin_x, origin_y, origin_z; - - Math3D.VectorScale(vup, 1.5f, up); - Math3D.VectorScale(vright, 1.5f, right); - - GL_Bind(r_particletexture.texnum); - ggl.glDepthMask(false); // no z buffering - ggl.glEnable(ggl.GL_BLEND); - GL_TexEnv(ggl.GL_MODULATE); - - ggl.glBegin(ggl.GL_TRIANGLES); - - FloatBuffer sourceVertices = particle_t.vertexArray; - IntBuffer sourceColors = particle_t.colorArray; - for (int j = 0, i = 0; i < num_particles; i++) { - origin_x = sourceVertices.get(j++); - origin_y = sourceVertices.get(j++); - origin_z = sourceVertices.get(j++); - - // hack a scale up to keep particles from disapearing - scale = (origin_x - r_origin[0]) * vpn[0] + (origin_y - r_origin[1]) * vpn[1] + (origin_z - r_origin[2]) * vpn[2]; - - scale = (scale < 20) ? 1 : 1 + scale * 0.004f; - - color = sourceColors.get(i); - - ggl.glColor4ub((byte) ((color) & 0xFF), - (byte) ((color >> 8) & 0xFF), - (byte) ((color >> 16) & 0xFF), - (byte) ((color >>> 24))); - - // first vertex - ggl.glTexCoord2f(0.0625f, 0.0625f); - ggl.glVertex3f(origin_x, origin_y, origin_z); - // second vertex - ggl.glTexCoord2f(1.0625f, 0.0625f); - ggl.glVertex3f(origin_x + up[0] * scale, origin_y + up[1] * scale, origin_z + up[2] * scale); - // third vertex - ggl.glTexCoord2f(0.0625f, 1.0625f); - ggl.glVertex3f(origin_x + right[0] * scale, origin_y + right[1] * scale, origin_z + right[2] * scale); - } - ggl.glEnd(); - - ggl.glDisable(ggl.GL_BLEND); - ggl.glColor4f(1, 1, 1, 1); - ggl.glDepthMask(true); // back to normal Z buffering - GL_TexEnv(ggl.GL_REPLACE); - } - - /** - * R_DrawParticles - */ - protected void R_DrawParticles() { - - if (gl_ext_pointparameters.value != 0.0f && qglPointParameterfEXT) { - - //ggl.glEnableClientState(ggl.GL_VERTEX_ARRAY); - ggl.glVertexPointer(3, ggl.GL_FLOAT, 0, particle_t.vertexArray); - ggl.glEnableClientState(ggl.GL_COLOR_ARRAY); - ggl.glColorPointer(4, ggl.GL_UNSIGNED_BYTE, 0, particle_t.getColorAsByteBuffer()); - - ggl.glDepthMask(false); - ggl.glEnable(ggl.GL_BLEND); - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glPointSize(gl_particle_size.value); - - ggl.glDrawArrays(ggl.GL_POINTS, 0, r_newrefdef.num_particles); - - ggl.glDisableClientState(ggl.GL_COLOR_ARRAY); - //ggl.glDisableClientState(ggl.GL_VERTEX_ARRAY); - - ggl.glDisable(ggl.GL_BLEND); - ggl.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); - ggl.glDepthMask(true); - ggl.glEnable(ggl.GL_TEXTURE_2D); - - } - else { - GL_DrawParticles(r_newrefdef.num_particles); - } - } - - /* - ============ - R_PolyBlend - ============ - */ - protected void R_PolyBlend() { - if (gl_polyblend.value == 0.0f) - return; - - if (v_blend[3] == 0.0f) - return; - - ggl.glDisable(ggl.GL_ALPHA_TEST); - ggl.glEnable(ggl.GL_BLEND); - ggl.glDisable(ggl.GL_DEPTH_TEST); - ggl.glDisable(ggl.GL_TEXTURE_2D); - - ggl.glLoadIdentity(); - - // FIXME: get rid of these - ggl.glRotatef(-90, 1, 0, 0); // put Z going up - ggl.glRotatef(90, 0, 0, 1); // put Z going up - - ggl.glColor4f(v_blend[0], v_blend[1], v_blend[2], v_blend[3]); - - ggl.glBegin(ggl.GL_QUADS); - - ggl.glVertex3f(10, 100, 100); - ggl.glVertex3f(10, -100, 100); - ggl.glVertex3f(10, -100, -100); - ggl.glVertex3f(10, 100, -100); - ggl.glEnd(); - - ggl.glDisable(ggl.GL_BLEND); - ggl.glEnable(ggl.GL_TEXTURE_2D); - ggl.glEnable(ggl.GL_ALPHA_TEST); - - ggl.glColor4f(1, 1, 1, 1); - } - - - /** - * R_SetPalette. - */ - protected void R_SetPalette(byte[] palette) { - // 256 RGB values (768 bytes) - // or null - int i; - int color = 0; - - if (palette != null) { - int j =0; - for (i = 0; i < 256; i++) { - color = (palette[j++] & 0xFF) << 0; - color |= (palette[j++] & 0xFF) << 8; - color |= (palette[j++] & 0xFF) << 16; - color |= 0xFF000000; - r_rawpalette[i] = color; - } - } - else { - for (i = 0; i < 256; i++) { - r_rawpalette[i] = d_8to24table[i] | 0xff000000; - } - } - GL_SetTexturePalette(r_rawpalette); - - ggl.glClearColor(0, 0, 0, 0); - ggl.glClear(ggl.GL_COLOR_BUFFER_BIT); - ggl.glClearColor(1f, 0f, 0.5f, 0.5f); - } - - - /** - * R_DrawBeam - */ - protected void R_DrawBeam(entity_t e) { - - int i; - float r, g, b; - - float[] perpvec = { 0, 0, 0 }; // vec3_t - float[] direction = { 0, 0, 0 }; // vec3_t - float[] normalized_direction = { 0, 0, 0 }; // vec3_t - - float[] oldorigin = { 0, 0, 0 }; // vec3_t - float[] origin = { 0, 0, 0 }; // vec3_t - - 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 (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]); - } - - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glEnable(ggl.GL_BLEND); - ggl.glDepthMask(false); - - r = (d_8to24table[e.skinnum & 0xFF]) & 0xFF; - g = (d_8to24table[e.skinnum & 0xFF] >> 8) & 0xFF; - b = (d_8to24table[e.skinnum & 0xFF] >> 16) & 0xFF; - - r *= 1 / 255.0f; - g *= 1 / 255.0f; - b *= 1 / 255.0f; - - ggl.glColor4f(r, g, b, e.alpha); - - ggl.glBegin(ggl.GL_TRIANGLE_STRIP); - - float[] v; - - for (i = 0; i < jake2.render.common.Main.NUM_BEAM_SEGS; i++) { - v = start_points[i]; - ggl.glVertex3f(v[0], v[1], v[2]); - v = end_points[i]; - ggl.glVertex3f(v[0], v[1], v[2]); - v = start_points[(i + 1) % jake2.render.common.Main.NUM_BEAM_SEGS]; - ggl.glVertex3f(v[0], v[1], v[2]); - v = end_points[(i + 1) % jake2.render.common.Main.NUM_BEAM_SEGS]; - ggl.glVertex3f(v[0], v[1], v[2]); - } - ggl.glEnd(); - - ggl.glEnable(ggl.GL_TEXTURE_2D); - ggl.glDisable(ggl.GL_BLEND); - ggl.glDepthMask(true); - } -} diff --git a/src/jake2/render/common/Mesh.java b/src/jake2/render/common/Mesh.java deleted file mode 100644 index f00f982..0000000 --- a/src/jake2/render/common/Mesh.java +++ /dev/null @@ -1,710 +0,0 @@ -/* -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. - -*/ - -// Created on 25.08.2006 by RST. - -// $Id: Mesh.java,v 1.2 2006-10-31 14:00:23 salomo Exp $ - -package jake2.render.common; - - -import jake2.Defines; -import jake2.client.VID; -import jake2.client.entity_t; -import jake2.qcommon.qfiles; -import jake2.render.image_t; -import jake2.util.Math3D; -import jake2.util.Vec3Cache; - -import java.nio.FloatBuffer; -import java.nio.IntBuffer; - -public abstract class Mesh extends Light { - - - protected static final int NUMVERTEXNORMALS = 162; - - protected float[][] r_avertexnormals = Anorms.VERTEXNORMALS; - - protected float[] shadevector = { 0, 0, 0 }; - - protected float[] shadelight = { 0, 0, 0 }; - - // precalculated dot products for quantized angles - protected static final int SHADEDOT_QUANT = 16; - - protected float[][] r_avertexnormal_dots = Anorms.VERTEXNORMAL_DOTS; - - protected float[] shadedots = r_avertexnormal_dots[0]; - - // bounding box - protected float[][] bbox = { - { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, - { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } - }; - - - /* - ================== - R_InitParticleTexture - ================== - */ - protected byte[][] dottexture = { { 0, 0, 0, 0, 0, 0, 0, 0 }, - { 0, 0, 1, 1, 0, 0, 0, 0 }, { 0, 1, 1, 1, 1, 0, 0, 0 }, - { 0, 1, 1, 1, 1, 0, 0, 0 }, { 0, 0, 1, 1, 0, 0, 0, 0 }, - { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 }, - { 0, 0, 0, 0, 0, 0, 0, 0 }, }; - - protected void R_InitParticleTexture() { - int x, y; - byte[] data = new byte[8 * 8 * 4]; - - // - // particle texture - // - for (x = 0; x < 8; x++) { - for (y = 0; y < 8; y++) { - data[y * 32 + x * 4 + 0] = (byte) 255; - data[y * 32 + x * 4 + 1] = (byte) 255; - data[y * 32 + x * 4 + 2] = (byte) 255; - data[y * 32 + x * 4 + 3] = (byte) (dottexture[x][y] * 255); - - } - } - r_particletexture = GL_LoadPic("***particle***", data, 8, 8, Base.it_sprite, 32); - - // - // also use this for bad textures, but without alpha - // - for (x = 0; x < 8; x++) { - for (y = 0; y < 8; y++) { - data[y * 32 + x * 4 + 0] = (byte) (dottexture[x & 3][y & 3] * 255); - data[y * 32 + x * 4 + 1] = 0; // dottexture[x&3][y&3]*255; - data[y * 32 + x * 4 + 2] = 0; // dottexture[x&3][y&3]*255; - data[y * 32 + x * 4 + 3] = (byte) 255; - } - } - r_notexture = GL_LoadPic("***r_notexture***", data, 8, 8, Base.it_wall, 32); - } - - /** - * GL_LerpVerts - */ - protected void GL_LerpVerts(int nverts, int[] ov, int[] v, float[] move, - float[] frontv, float[] backv) { - FloatBuffer lerp = vertexArrayBuf; - lerp.limit((nverts << 2) - nverts); // nverts * 3 - - int ovv, vv; - // PMM -- added RF_SHELL_DOUBLE, RF_SHELL_HALF_DAM - if ((currententity.flags & (Defines.RF_SHELL_RED - | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE - | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) { - float[] normal; - int j = 0; - for (int i = 0; i < nverts; i++/* , v++, ov++, lerp+=4 */) { - vv = v[i]; - normal = r_avertexnormals[(vv >>> 24) & 0xFF]; - ovv = ov[i]; - lerp.put(j, move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) * frontv[0] + normal[0] * Defines.POWERSUIT_SCALE); - lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) * frontv[1] + normal[1] * Defines.POWERSUIT_SCALE); - lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) * frontv[2] + normal[2] * Defines.POWERSUIT_SCALE); - j += 3; - } - } else { - int j = 0; - for (int i = 0; i < nverts; i++ /* , v++, ov++, lerp+=4 */) { - ovv = ov[i]; - vv = v[i]; - - lerp.put(j, move[0] + (ovv & 0xFF) * backv[0] + (vv & 0xFF) * frontv[0]); - lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) * frontv[1]); - lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) * frontv[2]); - j += 3; - } - } - } - - protected FloatBuffer colorArrayBuf = newFloatBuffer(qfiles.MAX_VERTS * 4); - protected FloatBuffer vertexArrayBuf = newFloatBuffer(qfiles.MAX_VERTS * 3); - protected FloatBuffer textureArrayBuf = newFloatBuffer(qfiles.MAX_VERTS * 2); - - protected boolean isFilled = false; - - protected float[] tmpVec = { 0, 0, 0 }; - - protected float[][] vectors = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } // 3 mal vec3_t - }; - - /** - * R_CullAliasModel - */ - // TODO sync with jogl renderer. hoz - protected boolean R_CullAliasModel(entity_t e) { - qfiles.dmdl_t paliashdr = (qfiles.dmdl_t) currentmodel.extradata; - - if ((e.frame >= paliashdr.num_frames) || (e.frame < 0)) { - VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such frame " + e.frame + '\n'); - e.frame = 0; - } - if ((e.oldframe >= paliashdr.num_frames) || (e.oldframe < 0)) { - VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such oldframe " + e.oldframe + '\n'); - e.oldframe = 0; - } - - qfiles.daliasframe_t pframe = paliashdr.aliasFrames[e.frame]; - qfiles.daliasframe_t poldframe = paliashdr.aliasFrames[e.oldframe]; - - /* - * * compute axially aligned mins and maxs - */ - float[] mins = Vec3Cache.get(); - float[] maxs = Vec3Cache.get(); - - if (pframe == poldframe) { - for (int i = 0; i < 3; i++) { - mins[i] = pframe.translate[i]; - maxs[i] = mins[i] + pframe.scale[i] * 255; - } - } else { - float thismaxs, oldmaxs; - for (int i = 0; i < 3; i++) { - thismaxs = pframe.translate[i] + pframe.scale[i] * 255; - - oldmaxs = poldframe.translate[i] + poldframe.scale[i] * 255; - - if (pframe.translate[i] < poldframe.translate[i]) - mins[i] = pframe.translate[i]; - else - mins[i] = poldframe.translate[i]; - - if (thismaxs > oldmaxs) - maxs[i] = thismaxs; - else - maxs[i] = oldmaxs; - } - } - - /* - * * compute a full bounding box - */ - float[] tmp; - for (int i = 0; i < 8; i++) { - tmp = bbox[i]; - if ((i & 1) != 0) - tmp[0] = mins[0]; - else - tmp[0] = maxs[0]; - - if ((i & 2) != 0) - tmp[1] = mins[1]; - else - tmp[1] = maxs[1]; - - if ((i & 4) != 0) - tmp[2] = mins[2]; - else - tmp[2] = maxs[2]; - } - - /* - * * rotate the bounding box - */ - tmp = mins; - Math3D.VectorCopy(e.angles, tmp); - tmp[Base.YAW] = -tmp[Base.YAW]; - Math3D.AngleVectors(tmp, vectors[0], vectors[1], vectors[2]); - - for (int i = 0; i < 8; i++) { - Math3D.VectorCopy(bbox[i], tmp); - - bbox[i][0] = Math3D.DotProduct(vectors[0], tmp); - bbox[i][1] = -Math3D.DotProduct(vectors[1], tmp); - bbox[i][2] = Math3D.DotProduct(vectors[2], tmp); - - Math3D.VectorAdd(e.origin, bbox[i], bbox[i]); - } - - Vec3Cache.release(2); // mins, maxs - - int f, mask; - int aggregatemask = ~0; // 0xFFFFFFFF - - for (int p = 0; p < 8; p++) { - mask = 0; - - for (f = 0; f < 4; f++) { - float dp = Math3D.DotProduct(frustum[f].normal, bbox[p]); - - if ((dp - frustum[f].dist) < 0) { - mask |= (1 << f); - } - } - - aggregatemask &= mask; - } - - if (aggregatemask != 0) { - return true; - } - - return false; - } - - /* - * ============================================================= - * - * ALIAS MODELS - * - * ============================================================= - */ - - protected void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, float backlerp) { - int count; - float alpha; - - - qfiles.daliasframe_t frame = paliashdr.aliasFrames[currententity.frame]; - - int[] verts = frame.verts; - - qfiles.daliasframe_t oldframe = paliashdr.aliasFrames[currententity.oldframe]; - - int[] ov = oldframe.verts; - - if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) - alpha = currententity.alpha; - else - alpha = 1.0f; - - // PMM - added double shell - if ((currententity.flags & (Defines.RF_SHELL_RED - | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE - | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) - ggl.glDisable(ggl.GL_TEXTURE_2D); - - float frontlerp = 1.0f - backlerp; - - float[] frontv = Vec3Cache.get(); // vec3_t - // move should be the delta back to the previous frame * backlerp - Math3D.VectorSubtract(currententity.oldorigin, currententity.origin, - frontv); - Math3D.AngleVectors(currententity.angles, vectors[0], vectors[1], - vectors[2]); - - float[] move = Vec3Cache.get(); // vec3_t - move[0] = Math3D.DotProduct(frontv, vectors[0]); // forward - move[1] = -Math3D.DotProduct(frontv, vectors[1]); // left - move[2] = Math3D.DotProduct(frontv, vectors[2]); // up - - Math3D.VectorAdd(move, oldframe.translate, move); - - float[] backv = Vec3Cache.get(); // vec3_t - for (int i = 0; i < 3; i++) { - move[i] = backlerp * move[i] + frontlerp * frame.translate[i]; - frontv[i] = frontlerp * frame.scale[i]; - backv[i] = backlerp * oldframe.scale[i]; - } - - // ab hier wird optimiert - - GL_LerpVerts(paliashdr.num_xyz, ov, verts, move, frontv, backv); - - Vec3Cache.release(3); // frontv, move, backv - - //ggl.glEnableClientState( ggl.GL_VERTEX_ARRAY ); - ggl.glVertexPointer(3, ggl.GL_FLOAT, 0, vertexArrayBuf); - - // PMM - added double damage shell - if ((currententity.flags & (Defines.RF_SHELL_RED - | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE - | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) { - ggl.glColor4f(shadelight[0], shadelight[1], shadelight[2], alpha); - } else { - ggl.glEnableClientState(ggl.GL_COLOR_ARRAY); - ggl.glColorPointer(4, ggl.GL_FLOAT, 0, colorArrayBuf); - - // - // pre light everything - // - FloatBuffer color = colorArrayBuf; - int j = 0; - float l; - for (int i = 0; i < paliashdr.num_xyz; i++) { - l = shadedots[(verts[i] >>> 24 ) & 0xFF]; - color.put(j, l * shadelight[0]); - color.put(j + 1, l * shadelight[1]); - color.put(j + 2, l * shadelight[2]); - color.put(j + 3, alpha); - j += 4; - } - } - - ggl.glClientActiveTextureARB(GL_TEXTURE0); - ggl.glTexCoordPointer(2, ggl.GL_FLOAT, 0, textureArrayBuf); - //ggl.glEnableClientState( ggl.GL_TEXTURE_COORD_ARRAY); - - int pos = 0; - int[] counts = paliashdr.counts; - - IntBuffer srcIndexBuf = null; - - FloatBuffer dstTextureCoords = textureArrayBuf; - FloatBuffer srcTextureCoords = paliashdr.textureCoordBuf; - - int dstIndex = 0; - int srcIndex = 0; - - for (int j = 0; j < counts.length; j++) { - - // get the vertex count and primitive type - count = counts[j]; - if (count == 0) - break; // done - - srcIndexBuf = paliashdr.indexElements[j]; - - int mode = ggl.GL_TRIANGLE_STRIP; - if (count < 0) { - mode = ggl.GL_TRIANGLE_FAN; - count = -count; - } - srcIndex = pos << 1; - for (int k = 0; k < count; k++) { - dstIndex = srcIndexBuf.get(k) << 1; - dstTextureCoords.put(dstIndex++, srcTextureCoords.get(srcIndex++)); - dstTextureCoords.put(dstIndex, srcTextureCoords.get(srcIndex++)); - } - - ggl.glDrawElements(mode, count, ggl.GL_UNSIGNED_INT, srcIndexBuf); - - pos += count; - } - - // PMM - added double damage shell - if ((currententity.flags & (Defines.RF_SHELL_RED - | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE - | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) - ggl.glEnable(ggl.GL_TEXTURE_2D); - - ggl.glDisableClientState(ggl.GL_COLOR_ARRAY); - } - - /** - * ============= GL_DrawAliasShadow ============= - */ - protected void GL_DrawAliasShadow(qfiles.dmdl_t paliashdr, int posenum) { - int[] order; - float height, lheight; - int count; - - lheight = currententity.origin[2] - lightspot[2]; - - height = 0; - - order = paliashdr.glCmds; - - height = -lheight + 1.0f; - - int orderIndex = 0; - int index = 0; - - // TODO shadow drawing with vertex arrays - - float[] point = Vec3Cache.get(); - while (true) { - // get the vertex count and primitive type - count = order[orderIndex++]; - if (count == 0) - break; // done - if (count < 0) { - count = -count; - ggl.glBegin(ggl.GL_TRIANGLE_FAN); - } - else - ggl.glBegin(ggl.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; - ggl.glVertex3f(point[0], point[1], point[2]); - - orderIndex += 3; - - } while (--count != 0); - - ggl.glEnd(); - } - Vec3Cache.release(); // point - } - - /* - ================= - R_DrawAliasModel - - ================= - */ - // TODO sync with jogl renderer. hoz - protected void R_DrawAliasModel(entity_t e) { - int i; - - image_t skin; - - if ((e.flags & Defines.RF_WEAPONMODEL) == 0) { - if (R_CullAliasModel(e)) - return; - } - - if ((e.flags & Defines.RF_WEAPONMODEL) != 0) { - if (r_lefthand.value == 2.0f) - return; - } - - qfiles.dmdl_t paliashdr = (qfiles.dmdl_t) currentmodel.extradata; - - // - // get lighting information - // - // PMM - rewrote, reordered to handle new shells & mixing - // PMM - 3.20 code .. replaced with original way of doing it to keep mod - // authors happy - // - if ((currententity.flags & (Defines.RF_SHELL_HALF_DAM - | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_RED - | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE)) != 0) { - Math3D.VectorClear(shadelight); - if ((currententity.flags & Defines.RF_SHELL_HALF_DAM) != 0) { - shadelight[0] = 0.56f; - shadelight[1] = 0.59f; - shadelight[2] = 0.45f; - } - if ((currententity.flags & Defines.RF_SHELL_DOUBLE) != 0) { - shadelight[0] = 0.9f; - shadelight[1] = 0.7f; - } - if ((currententity.flags & Defines.RF_SHELL_RED) != 0) - shadelight[0] = 1.0f; - if ((currententity.flags & Defines.RF_SHELL_GREEN) != 0) - shadelight[1] = 1.0f; - if ((currententity.flags & Defines.RF_SHELL_BLUE) != 0) - shadelight[2] = 1.0f; - } - - else if ((currententity.flags & Defines.RF_FULLBRIGHT) != 0) { - for (i = 0; i < 3; i++) - shadelight[i] = 1.0f; - } else { - R_LightPoint(currententity.origin, shadelight); - - // player lighting hack for communication back to server - // big hack! - if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0) { - // pick the greatest component, which should be the same - // as the mono value returned by software - if (shadelight[0] > shadelight[1]) { - if (shadelight[0] > shadelight[2]) - r_lightlevel.value = 150 * shadelight[0]; - else - r_lightlevel.value = 150 * shadelight[2]; - } else { - if (shadelight[1] > shadelight[2]) - r_lightlevel.value = 150 * shadelight[1]; - else - r_lightlevel.value = 150 * shadelight[2]; - } - } - - if (gl_monolightmap.string.charAt(0) != '0') { - float s = shadelight[0]; - - if (s < shadelight[1]) - s = shadelight[1]; - if (s < shadelight[2]) - s = shadelight[2]; - - shadelight[0] = s; - shadelight[1] = s; - shadelight[2] = s; - } - } - - if ((currententity.flags & Defines.RF_MINLIGHT) != 0) { - for (i = 0; i < 3; i++) - if (shadelight[i] > 0.1f) - break; - if (i == 3) { - shadelight[0] = 0.1f; - shadelight[1] = 0.1f; - shadelight[2] = 0.1f; - } - } - - if ((currententity.flags & Defines.RF_GLOW) != 0) { // bonus items will - // pulse with time - float scale; - float min; - - scale = (float) (0.1f * Math.sin(r_newrefdef.time * 7)); - for (i = 0; i < 3; i++) { - min = shadelight[i] * 0.8f; - shadelight[i] += scale; - if (shadelight[i] < min) - shadelight[i] = min; - } - } - - // ================= - // PGM ir goggles color override - if ((r_newrefdef.rdflags & Defines.RDF_IRGOGGLES) != 0 - && (currententity.flags & Defines.RF_IR_VISIBLE) != 0) { - shadelight[0] = 1.0f; - shadelight[1] = 0.0f; - shadelight[2] = 0.0f; - } - // PGM - // ================= - - shadedots = r_avertexnormal_dots[((int) (currententity.angles[1] * (SHADEDOT_QUANT / 360.0))) - & (SHADEDOT_QUANT - 1)]; - - float an = (float) (currententity.angles[1] / 180 * Math.PI); - shadevector[0] = (float) Math.cos(-an); - shadevector[1] = (float) Math.sin(-an); - shadevector[2] = 1; - Math3D.VectorNormalize(shadevector); - - // - // locate the proper data - // - c_alias_polys += paliashdr.num_tris; - - // - // draw all the triangles - // - if ((currententity.flags & Defines.RF_DEPTHHACK) != 0) - // hack the depth range to prevent view model from poking into walls - ggl.glDepthRange(gldepthmin, gldepthmin + 0.3 - * (gldepthmax - gldepthmin)); - - if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0 - && (r_lefthand.value == 1.0f)) { - ggl.glMatrixMode(ggl.GL_PROJECTION); - ggl.glPushMatrix(); - ggl.glLoadIdentity(); - ggl.glScalef(-1, 1, 1); - MYgluPerspective(r_newrefdef.fov_y, (float) r_newrefdef.width - / r_newrefdef.height, 4, 4096); - ggl.glMatrixMode(ggl.GL_MODELVIEW); - - ggl.glCullFace(ggl.GL_BACK); - } - - ggl.glPushMatrix(); - e.angles[Base.PITCH] = -e.angles[Base.PITCH]; // sigh. - R_RotateForEntity(e); - e.angles[Base.PITCH] = -e.angles[Base.PITCH]; // sigh. - - // select skin - if (currententity.skin != null) - skin = currententity.skin; // custom player skin - else { - if (currententity.skinnum >= qfiles.MAX_MD2SKINS) - skin = currentmodel.skins[0]; - else { - skin = currentmodel.skins[currententity.skinnum]; - if (skin == null) - skin = currentmodel.skins[0]; - } - } - if (skin == null) - skin = r_notexture; // fallback... - GL_Bind(skin.texnum); - - // draw it - - ggl.glShadeModel(ggl.GL_SMOOTH); - - GL_TexEnv(ggl.GL_MODULATE); - if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) { - ggl.glEnable(ggl.GL_BLEND); - } - - if ((currententity.frame >= paliashdr.num_frames) - || (currententity.frame < 0)) { - VID.Printf(Defines.PRINT_ALL, "R_DrawAliasModel " + currentmodel.name + ": no such frame " + currententity.frame - + '\n'); - currententity.frame = 0; - currententity.oldframe = 0; - } - - if ((currententity.oldframe >= paliashdr.num_frames) - || (currententity.oldframe < 0)) { - VID.Printf(Defines.PRINT_ALL, "R_DrawAliasModel " + currentmodel.name + ": no such oldframe " + currententity.oldframe + '\n'); - currententity.frame = 0; - currententity.oldframe = 0; - } - - if (r_lerpmodels.value == 0.0f) - currententity.backlerp = 0; - - GL_DrawAliasFrameLerp(paliashdr, currententity.backlerp); - - GL_TexEnv(ggl.GL_REPLACE); - ggl.glShadeModel(ggl.GL_FLAT); - - ggl.glPopMatrix(); - - if ((currententity.flags & Defines.RF_WEAPONMODEL) != 0 - && (r_lefthand.value == 1.0F)) { - ggl.glMatrixMode(ggl.GL_PROJECTION); - ggl.glPopMatrix(); - ggl.glMatrixMode(ggl.GL_MODELVIEW); - ggl.glCullFace(ggl.GL_FRONT); - } - - if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) { - ggl.glDisable(ggl.GL_BLEND); - } - - if ((currententity.flags & Defines.RF_DEPTHHACK) != 0) - ggl.glDepthRange(gldepthmin, gldepthmax); - - if (gl_shadows.value != 0.0f - && (currententity.flags & (Defines.RF_TRANSLUCENT | Defines.RF_WEAPONMODEL)) == 0) { - ggl.glPushMatrix(); - R_RotateForEntity(e); - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glEnable(ggl.GL_BLEND); - ggl.glColor4f(0, 0, 0, 0.5f); - GL_DrawAliasShadow(paliashdr, currententity.frame); - ggl.glEnable(ggl.GL_TEXTURE_2D); - ggl.glDisable(ggl.GL_BLEND); - ggl.glPopMatrix(); - } - ggl.glColor4f(1, 1, 1, 1); - } -} - diff --git a/src/jake2/render/common/Misc.java b/src/jake2/render/common/Misc.java deleted file mode 100644 index 01865ca..0000000 --- a/src/jake2/render/common/Misc.java +++ /dev/null @@ -1,54 +0,0 @@ -/* -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. - -*/ - -// Created on 25.08.2006 by RST. -// $Id: Misc.java,v 1.2 2006-10-31 14:00:23 salomo Exp $ - -package jake2.render.common; - - -import jake2.Defines; -import jake2.client.VID; - - -public abstract class Misc extends Mesh { - - /* - ================== - R_InitParticleTexture - ================== - */ - byte[][] dottexture = { - { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 1, 1, 0, 0, 0, 0 }, - { 0, 1, 1, 1, 1, 0, 0, 0 }, { 0, 1, 1, 1, 1, 0, 0, 0 }, - { 0, 0, 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 }, - { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 } - }; - - /** - * GL_Strings_f - */ - protected void GL_Strings_f() { - VID.Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n'); - VID.Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n'); - VID.Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n'); - VID.Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n'); - } -} diff --git a/src/jake2/render/common/Model.java b/src/jake2/render/common/Model.java deleted file mode 100644 index a1cdc3a..0000000 --- a/src/jake2/render/common/Model.java +++ /dev/null @@ -1,1250 +0,0 @@ -/* -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. - -*/ - -// Created on 19.08.2006 by RST. - -// $Id: Model.java,v 1.2 2006-10-31 14:00:23 salomo Exp $ - -package jake2.render.common; - - -import jake2.Defines; -import jake2.client.VID; -import jake2.game.cplane_t; -import jake2.game.cvar_t; -import jake2.qcommon.*; -import jake2.render.*; -import jake2.util.Math3D; -import jake2.util.Vargs; - -import java.nio.*; -import java.util.Arrays; -import java.util.Vector; - -/** - * model loading and caching. - */ -public abstract class Model extends Image { - - protected model_t loadmodel; - - protected int modfilelen; - - protected byte[] mod_novis = new byte[Defines.MAX_MAP_LEAFS / 8]; - - protected static final int MAX_MOD_KNOWN = 512; - - protected model_t[] mod_known = new model_t[MAX_MOD_KNOWN]; - - protected int mod_numknown; - - // the inline * models from the current map are kept seperate - protected model_t[] mod_inline = new model_t[MAX_MOD_KNOWN]; - - /** - * Mod_PointInLeaf - */ - protected mleaf_t Mod_PointInLeaf(float[] p, model_t model) { - mnode_t node; - float d; - cplane_t plane; - - if (model == null || model.nodes == null) - Com.Error(Defines.ERR_DROP, "Mod_PointInLeaf: bad model"); - - node = model.nodes[0]; // root node - while (true) { - if (node.contents != -1) - return (mleaf_t) node; - - plane = node.plane; - d = Math3D.DotProduct(p, plane.normal) - plane.dist; - if (d > 0) - node = node.children[0]; - else - node = node.children[1]; - } - // never reached - } - - protected byte[] decompressed = new byte[Defines.MAX_MAP_LEAFS / 8]; - - protected byte[] model_visibility = new byte[Defines.MAX_MAP_VISIBILITY]; - - /* - =================== - Mod_DecompressVis - =================== - */ - protected byte[] Mod_DecompressVis(byte[] in, int offset, model_t model) { - int c; - byte[] out; - int outp, inp; - int row; - - row = (model.vis.numclusters + 7) >> 3; - out = decompressed; - outp = 0; - inp = offset; - - if (in == null) { // no vis info, so make all visible - while (row != 0) { - out[outp++] = (byte) 0xFF; - row--; - } - return decompressed; - } - - do { - if (in[inp] != 0) { - out[outp++] = in[inp++]; - continue; - } - - c = in[inp + 1] & 0xFF; - inp += 2; - while (c != 0) { - out[outp++] = 0; - c--; - } - } while (outp < row); - - return decompressed; - } - - /** - * Mod_ClusterPVS - */ - protected byte[] Mod_ClusterPVS(int cluster, model_t model) { - if (cluster == -1 || model.vis == null) - return mod_novis; - - return Mod_DecompressVis(model_visibility, model.vis.bitofs[cluster][Defines.DVIS_PVS], model); - } - - /** - * Mod_Modellist_f - */ - protected void Mod_Modellist_f() { - int i; - model_t mod; - int total; - - total = 0; - VID.Printf(Defines.PRINT_ALL, "Loaded models:\n"); - for (i = 0; i < mod_numknown; i++) { - mod = mod_known[i]; - if (mod.name.length() == 0) - continue; - - VID.Printf(Defines.PRINT_ALL, "%8i : %s\n", new Vargs(2).add(mod.extradatasize).add(mod.name)); - total += mod.extradatasize; - } - VID.Printf(Defines.PRINT_ALL, "Total resident: " + total + '\n'); - } - - /** - * Mod_Init. - */ - protected void Mod_Init() { - // init mod_known - for (int i = 0; i < MAX_MOD_KNOWN; i++) { - mod_known[i] = new model_t(); - } - Arrays.fill(mod_novis, (byte) 0xff); - } - - protected byte[] fileBuffer; - - /** - * Mod_ForName. - * - * Loads in a model for the given name. - */ - protected model_t Mod_ForName(String name, boolean crash) { - model_t mod = null; - int i; - - if (name == null || name.length() == 0) - Com.Error(Defines.ERR_DROP, "Mod_ForName: NULL name"); - - // - // inline models are grabbed only from worldmodel - // - if (name.charAt(0) == '*') { - i = Integer.parseInt(name.substring(1)); - if (i < 1 || r_worldmodel == null || i >= r_worldmodel.numsubmodels) - Com.Error(Defines.ERR_DROP, "bad inline model number"); - return mod_inline[i]; - } - - // - // search the currently loaded models - // - for (i = 0; i < mod_numknown; i++) { - mod = mod_known[i]; - - if (mod.name.length() == 0) - continue; - if (mod.name.equals(name)) - return mod; - } - - // - // find a free model slot spot - // - for (i = 0; i < mod_numknown; i++) { - mod = mod_known[i]; - - if (mod.name.length() == 0) - break; // free spot - } - if (i == mod_numknown) { - if (mod_numknown == MAX_MOD_KNOWN) - Com.Error(Defines.ERR_DROP, "mod_numknown == MAX_MOD_KNOWN"); - mod_numknown++; - mod = mod_known[i]; - } - - mod.name = name; - - // - // load the file - // - fileBuffer = FS.LoadFile(name); - - if (fileBuffer == null) { - if (crash) - Com.Error(Defines.ERR_DROP, "Mod_NumForName: " + mod.name - + " not found"); - - mod.name = ""; - return null; - } - - modfilelen = fileBuffer.length; - - loadmodel = mod; - - // - // fill it in - // - ByteBuffer bb = ByteBuffer.wrap(fileBuffer); - bb.order(ByteOrder.LITTLE_ENDIAN); - - // call the apropriate loader - - bb.mark(); - int ident = bb.getInt(); - - bb.reset(); - - switch (ident) { - case qfiles.IDALIASHEADER: - Mod_LoadAliasModel(mod, bb); - break; - case qfiles.IDSPRITEHEADER: - Mod_LoadSpriteModel(mod, bb); - break; - case qfiles.IDBSPHEADER: - Mod_LoadBrushModel(mod, bb); - break; - default: - Com.Error(Defines.ERR_DROP, "Mod_NumForName: unknown fileid for " + mod.name); - break; - } - - this.fileBuffer = null; // free it for garbage collection - return mod; - } - - /* - * =============================================================================== - * - * BRUSHMODEL LOADING - * - * =============================================================================== - */ - - protected byte[] mod_base; - - /** - * Mod_LoadLighting. - */ - protected void Mod_LoadLighting(lump_t l) { - if (l.filelen == 0) { - loadmodel.lightdata = null; - return; - } - loadmodel.lightdata = new byte[l.filelen]; - System.arraycopy(mod_base, l.fileofs, loadmodel.lightdata, 0, l.filelen); - } - - /** - * Mod_LoadVisibility. - */ - protected void Mod_LoadVisibility(lump_t l) { - - if (l.filelen == 0) { - loadmodel.vis = null; - return; - } - - System.arraycopy(mod_base, l.fileofs, model_visibility, 0, l.filelen); - - ByteBuffer bb = ByteBuffer.wrap(model_visibility, 0, l.filelen); - - loadmodel.vis = new qfiles.dvis_t(bb.order(ByteOrder.LITTLE_ENDIAN)); - - } - - /** - * Mod_LoadVertexes. - */ - protected void Mod_LoadVertexes(lump_t l) { - mvertex_t[] vertexes; - int i, count; - - if ((l.filelen % mvertex_t.DISK_SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); - - count = l.filelen / mvertex_t.DISK_SIZE; - - vertexes = new mvertex_t[count]; - - loadmodel.vertexes = vertexes; - loadmodel.numvertexes = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - for (i = 0; i < count; i++) { - vertexes[i] = new mvertex_t(bb); - } - } - - /** - * RadiusFromBounds - */ - protected float RadiusFromBounds(float[] mins, float[] maxs) { - float[] corner = { 0, 0, 0 }; - - for (int i = 0; i < 3; i++) { - corner[i] = Math.abs(mins[i]) > Math.abs(maxs[i]) ? Math.abs(mins[i]) : Math.abs(maxs[i]); - } - return Math3D.VectorLength(corner); - } - - /** - * Mod_LoadSubmodels. - */ - protected void Mod_LoadSubmodels(lump_t l) { - - if ((l.filelen % qfiles.dmodel_t.SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); - - int i, j; - - int count = l.filelen / qfiles.dmodel_t.SIZE; - // out = Hunk_Alloc ( count*sizeof(*out)); - mmodel_t out; - mmodel_t[] outs = new mmodel_t[count]; - for (i = 0; i < count; i++) { - outs[i] = new mmodel_t(); - } - - loadmodel.submodels = outs; - loadmodel.numsubmodels = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - qfiles.dmodel_t in; - - for (i = 0; i < count; i++) { - in = new qfiles.dmodel_t(bb); - out = outs[i]; - for (j = 0; j < 3; j++) { // spread the mins / maxs by a - // pixel - out.mins[j] = in.mins[j] - 1; - out.maxs[j] = in.maxs[j] + 1; - out.origin[j] = in.origin[j]; - } - out.radius = RadiusFromBounds(out.mins, out.maxs); - out.headnode = in.headnode; - out.firstface = in.firstface; - out.numfaces = in.numfaces; - } - } - - /* - * ================= Mod_LoadEdges ================= - */ - protected void Mod_LoadEdges(lump_t l) { - medge_t[] edges; - int i, count; - - if ((l.filelen % medge_t.DISK_SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " - + loadmodel.name); - - count = l.filelen / medge_t.DISK_SIZE; - // out = Hunk_Alloc ( (count + 1) * sizeof(*out)); - edges = new medge_t[count + 1]; - - loadmodel.edges = edges; - loadmodel.numedges = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - for (i = 0; i < count; i++) { - edges[i] = new medge_t(bb); - } - } - - /* - * ================= Mod_LoadTexinfo ================= - */ - protected void Mod_LoadTexinfo(lump_t l) { - texinfo_t in; - mtexinfo_t[] out; - mtexinfo_t step; - int i, j, count; - int next; - String name; - - if ((l.filelen % texinfo_t.SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); - - count = l.filelen / texinfo_t.SIZE; - // out = Hunk_Alloc ( count*sizeof(*out)); - out = new mtexinfo_t[count]; - for (i = 0; i < count; i++) { - out[i] = new mtexinfo_t(); - } - - loadmodel.texinfo = out; - loadmodel.numtexinfo = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - for (i = 0; i < count; i++) { - - in = new texinfo_t(bb); - out[i].vecs = in.vecs; - out[i].flags = in.flags; - next = in.nexttexinfo; - if (next > 0) - out[i].next = loadmodel.texinfo[next]; - else - out[i].next = null; - - name = "textures/" + in.texture + ".wal"; - - out[i].image = GL_FindImage(name, Base.it_wall); - if (out[i].image == null) { - VID.Printf(Defines.PRINT_ALL, "Couldn't load " + name + '\n'); - out[i].image = r_notexture; - } - } - - // count animation frames - for (i = 0; i < count; i++) { - out[i].numframes = 1; - for (step = out[i].next; (step != null) && (step != out[i]); step = step.next) - out[i].numframes++; - } - } - - /* - ================ - CalcSurfaceExtents - - Fills in s.texturemins[] and s.extents[] - ================ - */ - protected void CalcSurfaceExtents(msurface_t s) { - float[] mins = { 0, 0 }; - float[] maxs = { 0, 0 }; - float val; - - int j, e; - mvertex_t v; - int[] bmins = { 0, 0 }; - int[] bmaxs = { 0, 0 }; - - mins[0] = mins[1] = 999999; - maxs[0] = maxs[1] = -99999; - - mtexinfo_t tex = s.texinfo; - - for (int i = 0; i < s.numedges; i++) { - e = loadmodel.surfedges[s.firstedge + i]; - if (e >= 0) - v = loadmodel.vertexes[loadmodel.edges[e].v[0]]; - else - v = loadmodel.vertexes[loadmodel.edges[-e].v[1]]; - - for (j = 0; j < 2; j++) { - val = v.position[0] * tex.vecs[j][0] + v.position[1] - * tex.vecs[j][1] + v.position[2] * tex.vecs[j][2] - + tex.vecs[j][3]; - if (val < mins[j]) - mins[j] = val; - if (val > maxs[j]) - maxs[j] = val; - } - } - - for (int i = 0; i < 2; i++) { - bmins[i] = (int) Math.floor(mins[i] / 16); - bmaxs[i] = (int) Math.ceil(maxs[i] / 16); - - s.texturemins[i] = (short) (bmins[i] * 16); - s.extents[i] = (short) ((bmaxs[i] - bmins[i]) * 16); - - } - } - - /* - * ================= Mod_LoadFaces ================= - */ - protected void Mod_LoadFaces(lump_t l) { - - int i, surfnum; - int planenum, side; - int ti; - - if ((l.filelen % qfiles.dface_t.SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " - + loadmodel.name); - - int count = l.filelen / qfiles.dface_t.SIZE; - // out = Hunk_Alloc ( count*sizeof(*out)); - msurface_t[] outs = new msurface_t[count]; - for (i = 0; i < count; i++) { - outs[i] = new msurface_t(); - } - - loadmodel.surfaces = outs; - loadmodel.numsurfaces = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - currentmodel = loadmodel; - - GL_BeginBuildingLightmaps(loadmodel); - - qfiles.dface_t in; - msurface_t out; - - for (surfnum = 0; surfnum < count; surfnum++) { - in = new qfiles.dface_t(bb); - out = outs[surfnum]; - out.firstedge = in.firstedge; - out.numedges = in.numedges; - out.flags = 0; - out.polys = null; - - planenum = in.planenum; - side = in.side; - if (side != 0) - out.flags |= Defines.SURF_PLANEBACK; - - out.plane = loadmodel.planes[planenum]; - - ti = in.texinfo; - if (ti < 0 || ti >= loadmodel.numtexinfo) - Com.Error(Defines.ERR_DROP, - "MOD_LoadBmodel: bad texinfo number"); - - out.texinfo = loadmodel.texinfo[ti]; - - CalcSurfaceExtents(out); - - // lighting info - - for (i = 0; i < Defines.MAXLIGHTMAPS; i++) - out.styles[i] = in.styles[i]; - - i = in.lightofs; - if (i == -1) - out.samples = null; - else { - ByteBuffer pointer = ByteBuffer.wrap(loadmodel.lightdata); - pointer.position(i); - pointer = pointer.slice(); - pointer.mark(); - out.samples = pointer; // subarray - } - - // set the drawing flags - - if ((out.texinfo.flags & Defines.SURF_WARP) != 0) { - out.flags |= Defines.SURF_DRAWTURB; - for (i = 0; i < 2; i++) { - out.extents[i] = 16384; - out.texturemins[i] = -8192; - } - GL_SubdivideSurface(out); // cut up polygon for warps - } - - // create lightmaps and polygons - if ((out.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 - | Defines.SURF_TRANS66 | Defines.SURF_WARP)) == 0) - GL_CreateSurfaceLightmap(out); - - if ((out.texinfo.flags & Defines.SURF_WARP) == 0) - GL_BuildPolygonFromSurface(out); - - } - GL_EndBuildingLightmaps(); - } - - /* - * ================= Mod_SetParent ================= - */ - protected void Mod_SetParent(mnode_t node, mnode_t parent) { - node.parent = parent; - if (node.contents != -1) - return; - Mod_SetParent(node.children[0], node); - Mod_SetParent(node.children[1], node); - } - - /* - * ================= Mod_LoadNodes ================= - */ - protected void Mod_LoadNodes(lump_t l) { - int i, j, count, p; - qfiles.dnode_t in; - mnode_t[] out; - - if ((l.filelen % qfiles.dnode_t.SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " - + loadmodel.name); - - count = l.filelen / qfiles.dnode_t.SIZE; - // out = Hunk_Alloc ( count*sizeof(*out)); - out = new mnode_t[count]; - - loadmodel.nodes = out; - loadmodel.numnodes = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - // initialize the tree array - for (i = 0; i < count; i++) - out[i] = new mnode_t(); // do first before linking - - // fill and link the nodes - for (i = 0; i < count; i++) { - in = new qfiles.dnode_t(bb); - for (j = 0; j < 3; j++) { - out[i].mins[j] = in.mins[j]; - out[i].maxs[j] = in.maxs[j]; - } - - p = in.planenum; - out[i].plane = loadmodel.planes[p]; - - out[i].firstsurface = in.firstface; - out[i].numsurfaces = in.numfaces; - out[i].contents = -1; // differentiate from leafs - - for (j = 0; j < 2; j++) { - p = in.children[j]; - if (p >= 0) - out[i].children[j] = loadmodel.nodes[p]; - else - out[i].children[j] = loadmodel.leafs[-1 - p]; // mleaf_t - // extends - // mnode_t - } - } - - Mod_SetParent(loadmodel.nodes[0], null); // sets nodes and leafs - } - - /* - * ================= Mod_LoadLeafs ================= - */ - protected void Mod_LoadLeafs(lump_t l) { - qfiles.dleaf_t in; - mleaf_t[] out; - int i, j, count, p; - - if ((l.filelen % qfiles.dleaf_t.SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " - + loadmodel.name); - - count = l.filelen / qfiles.dleaf_t.SIZE; - // out = Hunk_Alloc ( count*sizeof(*out)); - out = new mleaf_t[count]; - - loadmodel.leafs = out; - loadmodel.numleafs = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - for (i = 0; i < count; i++) { - in = new qfiles.dleaf_t(bb); - out[i] = new mleaf_t(); - for (j = 0; j < 3; j++) { - out[i].mins[j] = in.mins[j]; - out[i].maxs[j] = in.maxs[j]; - - } - - out[i].contents = in.contents; - out[i].cluster = in.cluster; - out[i].area = in.area; - - out[i].setMarkSurface(in.firstleafface, loadmodel.marksurfaces); - out[i].nummarksurfaces = in.numleaffaces; - } - } - - /* - * ================= Mod_LoadMarksurfaces ================= - */ - protected void Mod_LoadMarksurfaces(lump_t l) { - int i, j, count; - - msurface_t[] out; - - if ((l.filelen % Defines.SIZE_OF_SHORT) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " - + loadmodel.name); - count = l.filelen / Defines.SIZE_OF_SHORT; - // out = Hunk_Alloc ( count*sizeof(*out)); - out = new msurface_t[count]; - - loadmodel.marksurfaces = out; - loadmodel.nummarksurfaces = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - for (i = 0; i < count; i++) { - j = bb.getShort(); - if (j < 0 || j >= loadmodel.numsurfaces) - Com.Error(Defines.ERR_DROP, - "Mod_ParseMarksurfaces: bad surface number"); - - out[i] = loadmodel.surfaces[j]; - } - } - - /* - * ================= Mod_LoadSurfedges ================= - */ - protected void Mod_LoadSurfedges(lump_t l) { - int i, count; - int[] offsets; - - if ((l.filelen % Defines.SIZE_OF_INT) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " - + loadmodel.name); - - count = l.filelen / Defines.SIZE_OF_INT; - if (count < 1 || count >= Defines.MAX_MAP_SURFEDGES) - Com.Error(Defines.ERR_DROP, - "MOD_LoadBmodel: bad surfedges count in " + loadmodel.name - + ": " + count); - - offsets = new int[count]; - - loadmodel.surfedges = offsets; - loadmodel.numsurfedges = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - for (i = 0; i < count; i++) - offsets[i] = bb.getInt(); - } - - /* - * ================= Mod_LoadPlanes ================= - */ - protected void Mod_LoadPlanes(lump_t l) { - int i, j; - cplane_t[] out; - qfiles.dplane_t in; - int count; - int bits; - - if ((l.filelen % qfiles.dplane_t.SIZE) != 0) - Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " - + loadmodel.name); - - count = l.filelen / qfiles.dplane_t.SIZE; - // out = Hunk_Alloc ( count*2*sizeof(*out)); - out = new cplane_t[count * 2]; - for (i = 0; i < count; i++) { - out[i] = new cplane_t(); - } - - loadmodel.planes = out; - loadmodel.numplanes = count; - - ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); - bb.order(ByteOrder.LITTLE_ENDIAN); - - for (i = 0; i < count; i++) { - bits = 0; - in = new qfiles.dplane_t(bb); - for (j = 0; j < 3; j++) { - out[i].normal[j] = in.normal[j]; - if (out[i].normal[j] < 0) - bits |= (1 << j); - } - - out[i].dist = in.dist; - out[i].type = (byte) in.type; - out[i].signbits = (byte) bits; - } - } - - /* - * ================= Mod_LoadBrushModel ================= - */ - protected void Mod_LoadBrushModel(model_t mod, ByteBuffer buffer) { - int i; - qfiles.dheader_t header; - mmodel_t bm; - - loadmodel.type = Base.mod_brush; - if (loadmodel != mod_known[0]) - Com.Error(Defines.ERR_DROP, "Loaded a brush model after the world"); - - header = new qfiles.dheader_t(buffer); - - i = header.version; - if (i != Defines.BSPVERSION) - Com.Error(Defines.ERR_DROP, "Mod_LoadBrushModel: " + mod.name - + " has wrong version number (" + i + " should be " - + Defines.BSPVERSION + ")"); - - mod_base = fileBuffer; // (byte *)header; - - // load into heap - Mod_LoadVertexes(header.lumps[Defines.LUMP_VERTEXES]); // ok - Mod_LoadEdges(header.lumps[Defines.LUMP_EDGES]); // ok - Mod_LoadSurfedges(header.lumps[Defines.LUMP_SURFEDGES]); // ok - Mod_LoadLighting(header.lumps[Defines.LUMP_LIGHTING]); // ok - Mod_LoadPlanes(header.lumps[Defines.LUMP_PLANES]); // ok - Mod_LoadTexinfo(header.lumps[Defines.LUMP_TEXINFO]); // ok - Mod_LoadFaces(header.lumps[Defines.LUMP_FACES]); // ok - Mod_LoadMarksurfaces(header.lumps[Defines.LUMP_LEAFFACES]); - Mod_LoadVisibility(header.lumps[Defines.LUMP_VISIBILITY]); // ok - Mod_LoadLeafs(header.lumps[Defines.LUMP_LEAFS]); // ok - Mod_LoadNodes(header.lumps[Defines.LUMP_NODES]); // ok - Mod_LoadSubmodels(header.lumps[Defines.LUMP_MODELS]); - mod.numframes = 2; // regular and alternate animation - - // - // set up the submodels - // - model_t starmod; - - for (i = 0; i < mod.numsubmodels; i++) { - - bm = mod.submodels[i]; - starmod = mod_inline[i] = loadmodel.copy(); - - starmod.firstmodelsurface = bm.firstface; - starmod.nummodelsurfaces = bm.numfaces; - starmod.firstnode = bm.headnode; - if (starmod.firstnode >= loadmodel.numnodes) - Com.Error(Defines.ERR_DROP, "Inline model " + i - + " has bad firstnode"); - - Math3D.VectorCopy(bm.maxs, starmod.maxs); - Math3D.VectorCopy(bm.mins, starmod.mins); - starmod.radius = bm.radius; - - if (i == 0) - loadmodel = starmod.copy(); - - starmod.numleafs = bm.visleafs; - } - } - - /* - * ============================================================================== - * - * ALIAS MODELS - * - * ============================================================================== - */ - - /** - * Mod_LoadAliasModel. - */ - protected void Mod_LoadAliasModel(model_t mod, ByteBuffer buffer) { - int i, j; - qfiles.dmdl_t pheader; - qfiles.dstvert_t[] poutst; - qfiles.dtriangle_t[] pouttri; - qfiles.daliasframe_t[] poutframe; - int[] poutcmd; - - pheader = new qfiles.dmdl_t(buffer); - - if (pheader.version != qfiles.ALIAS_VERSION) - Com.Error(Defines.ERR_DROP, - "%s has wrong version number (%i should be %i)", new Vargs( - 3).add(mod.name).add(pheader.version).add( - qfiles.ALIAS_VERSION)); - - if (pheader.skinheight > Base.MAX_LBM_HEIGHT) - Com.Error(Defines.ERR_DROP, "model " + mod.name - + " has a skin taller than " + Base.MAX_LBM_HEIGHT); - - if (pheader.num_xyz <= 0) - Com.Error(Defines.ERR_DROP, "model " + mod.name - + " has no vertices"); - - if (pheader.num_xyz > qfiles.MAX_VERTS) - Com.Error(Defines.ERR_DROP, "model " + mod.name - + " has too many vertices"); - - if (pheader.num_st <= 0) - Com.Error(Defines.ERR_DROP, "model " + mod.name - + " has no st vertices"); - - if (pheader.num_tris <= 0) - Com.Error(Defines.ERR_DROP, "model " + mod.name - + " has no triangles"); - - if (pheader.num_frames <= 0) - Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no frames"); - - // - // load base s and t vertices (not used in gl version) - // - poutst = new qfiles.dstvert_t[pheader.num_st]; - buffer.position(pheader.ofs_st); - for (i = 0; i < pheader.num_st; i++) { - poutst[i] = new qfiles.dstvert_t(buffer); - } - - // - // load triangle lists - // - pouttri = new qfiles.dtriangle_t[pheader.num_tris]; - buffer.position(pheader.ofs_tris); - for (i = 0; i < pheader.num_tris; i++) { - pouttri[i] = new qfiles.dtriangle_t(buffer); - } - - // - // load the frames - // - poutframe = new qfiles.daliasframe_t[pheader.num_frames]; - buffer.position(pheader.ofs_frames); - for (i = 0; i < pheader.num_frames; i++) { - poutframe[i] = new qfiles.daliasframe_t(buffer); - // verts are all 8 bit, so no swapping needed - poutframe[i].verts = new int[pheader.num_xyz]; - for (int k = 0; k < pheader.num_xyz; k++) { - poutframe[i].verts[k] = buffer.getInt(); - } - } - - mod.type = Base.mod_alias; - - // - // load the glcmds - // - poutcmd = new int[pheader.num_glcmds]; - buffer.position(pheader.ofs_glcmds); - for (i = 0; i < pheader.num_glcmds; i++) - poutcmd[i] = buffer.getInt(); // LittleLong (pincmd[i]); - - // register all skins - String[] skinNames = new String[pheader.num_skins]; - byte[] nameBuf = new byte[qfiles.MAX_SKINNAME]; - buffer.position(pheader.ofs_skins); - for (i = 0; i < pheader.num_skins; i++) { - buffer.get(nameBuf); - skinNames[i] = new String(nameBuf); - int n = skinNames[i].indexOf('\0'); - if (n > -1) { - skinNames[i] = skinNames[i].substring(0, n); - } - mod.skins[i] = GL_FindImage(skinNames[i], Base.it_skin); - } - - // set the model arrays - pheader.skinNames = skinNames; // skin names - pheader.stVerts = poutst; // textur koordinaten - pheader.triAngles = pouttri; // dreiecke - pheader.glCmds = poutcmd; // STRIP or FAN - pheader.aliasFrames = poutframe; // frames mit vertex array - - mod.extradata = pheader; - - mod.mins[0] = -32; - mod.mins[1] = -32; - mod.mins[2] = -32; - mod.maxs[0] = 32; - mod.maxs[1] = 32; - mod.maxs[2] = 32; - - if (fastjogl) - precompileGLCmds(pheader); - } - - boolean fastjogl = true; - - /* - * ============================================================================== - * - * SPRITE MODELS - * - * ============================================================================== - */ - - /* - * ================= Mod_LoadSpriteModel ================= - */ - protected void Mod_LoadSpriteModel(model_t mod, ByteBuffer buffer) { - qfiles.dsprite_t sprout = new qfiles.dsprite_t(buffer); - - if (sprout.version != qfiles.SPRITE_VERSION) - Com.Error(Defines.ERR_DROP, - "%s has wrong version number (%i should be %i)", new Vargs( - 3).add(mod.name).add(sprout.version).add( - qfiles.SPRITE_VERSION)); - - if (sprout.numframes > qfiles.MAX_MD2SKINS) - Com.Error(Defines.ERR_DROP, "%s has too many frames (%i > %i)", - new Vargs(3).add(mod.name).add(sprout.numframes).add( - qfiles.MAX_MD2SKINS)); - - for (int i = 0; i < sprout.numframes; i++) { - mod.skins[i] = GL_FindImage(sprout.frames[i].name, Base.it_sprite); - } - - mod.type = Base.mod_sprite; - mod.extradata = sprout; - } - - // ============================================================================= - - /* - * @@@@@@@@@@@@@@@@@@@@@ - * R_BeginRegistration - * - * Specifies the model that will be used as the world - * @@@@@@@@@@@@@@@@@@@@@ - */ - protected void R_BeginRegistration(String model) { - - if (fastjogl) - resetModelArrays(); - - Polygon.reset(); - - cvar_t flushmap; - - registration_sequence++; - r_oldviewcluster = -1; // force markleafs - - String fullname = "maps/" + model + ".bsp"; - - // explicitly free the old map if different - // this guarantees that mod_known[0] is the world map - flushmap = Cvar.Get("flushmap", "0", 0); - if (!mod_known[0].name.equals(fullname) || flushmap.value != 0.0f) - Mod_Free(mod_known[0]); - r_worldmodel = Mod_ForName(fullname, true); - - r_viewcluster = -1; - } - - /* - * @@@@@@@@@@@@@@@@@@@@@ R_RegisterModel - * - * @@@@@@@@@@@@@@@@@@@@@ - */ - protected model_t R_RegisterModel(String name) { - model_t mod = null; - int i; - qfiles.dsprite_t sprout; - qfiles.dmdl_t pheader; - - mod = Mod_ForName(name, false); - if (mod != null) { - mod.registration_sequence = registration_sequence; - - // register any images used by the models - if (mod.type == Base.mod_sprite) { - sprout = (qfiles.dsprite_t) mod.extradata; - for (i = 0; i < sprout.numframes; i++) - mod.skins[i] = GL_FindImage(sprout.frames[i].name, - Base.it_sprite); - } else if (mod.type == Base.mod_alias) { - pheader = (qfiles.dmdl_t) mod.extradata; - for (i = 0; i < pheader.num_skins; i++) - mod.skins[i] = GL_FindImage(pheader.skinNames[i], - Base.it_skin); - // PGM - mod.numframes = pheader.num_frames; - // PGM - } else if (mod.type == Base.mod_brush) { - for (i = 0; i < mod.numtexinfo; i++) - mod.texinfo[i].image.registration_sequence = registration_sequence; - } - } - return mod; - } - - /* - * @@@@@@@@@@@@@@@@@@@@@ R_EndRegistration - * - * @@@@@@@@@@@@@@@@@@@@@ - */ - protected void R_EndRegistration() { - model_t mod; - - for (int i = 0; i < mod_numknown; i++) { - mod = mod_known[i]; - if (mod.name.length() == 0) - continue; - if (mod.registration_sequence != registration_sequence) { // don't - // need - // this - // model - Mod_Free(mod); - } else { - // precompile AliasModels - if (fastjogl) - if (mod.type == Base.mod_alias) - precompileGLCmds((qfiles.dmdl_t) mod.extradata); - } - } - GL_FreeUnusedImages(); - - // modelMemoryUsage(); - } - - // ============================================================================= - - /* - * ================ Mod_Free ================ - */ - protected void Mod_Free(model_t mod) { - mod.clear(); - } - - /* - * ================ Mod_FreeAll ================ - */ - protected void Mod_FreeAll() { - for (int i = 0; i < mod_numknown; i++) { - if (mod_known[i].extradata != null) - Mod_Free(mod_known[i]); - } - } - - /* - * new functions for vertex array handling - */ - protected static final int MODEL_BUFFER_SIZE = 50000; - - protected static FloatBuffer globalModelTextureCoordBuf = - newFloatBuffer(MODEL_BUFFER_SIZE * 2); - - protected static IntBuffer globalModelVertexIndexBuf = - newIntBuffer(MODEL_BUFFER_SIZE); - - protected void precompileGLCmds(qfiles.dmdl_t model) { - model.textureCoordBuf = globalModelTextureCoordBuf.slice(); - model.vertexIndexBuf = globalModelVertexIndexBuf.slice(); - Vector tmp = new Vector(); - - int count = 0; - int[] order = model.glCmds; - int orderIndex = 0; - while (true) { - // get the vertex count and primitive type - count = order[orderIndex++]; - if (count == 0) - break; // done - - tmp.addElement(new Integer(count)); - - if (count < 0) { - count = -count; - // gl.glBegin (GL.GL_TRIANGLE_FAN); - } else { - // gl.glBegin (GL.GL_TRIANGLE_STRIP); - } - - do { - // texture coordinates come from the draw list - globalModelTextureCoordBuf.put(Float - .intBitsToFloat(order[orderIndex + 0])); - globalModelTextureCoordBuf.put(Float - .intBitsToFloat(order[orderIndex + 1])); - globalModelVertexIndexBuf.put(order[orderIndex + 2]); - - orderIndex += 3; - } while (--count != 0); - } - - int size = tmp.size(); - - model.counts = new int[size]; - model.indexElements = new IntBuffer[size]; - - count = 0; - int pos = 0; - for (int i = 0; i < model.counts.length; i++) { - count = ((Integer) tmp.get(i)).intValue(); - model.counts[i] = count; - - count = (count < 0) ? -count : count; - model.vertexIndexBuf.position(pos); - model.indexElements[i] = model.vertexIndexBuf.slice(); - model.indexElements[i].limit(count); - pos += count; - } - } - - protected static void resetModelArrays() { - globalModelTextureCoordBuf.rewind(); - globalModelVertexIndexBuf.rewind(); - } - - protected static void modelMemoryUsage() { - System.out.println("AliasModels: globalVertexBuffer size " - + globalModelVertexIndexBuf.position()); - } -} diff --git a/src/jake2/render/common/Polygon.java b/src/jake2/render/common/Polygon.java deleted file mode 100644 index 38537d9..0000000 --- a/src/jake2/render/common/Polygon.java +++ /dev/null @@ -1,164 +0,0 @@ -/* - * Polygon.java - * Copyright (C) 2003 - * - * $Id: Polygon.java,v 1.1 2006-10-31 13:06:32 salomo 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.common; - -import jake2.render.glpoly_t; -import jake2.util.Lib; - -import java.nio.FloatBuffer; - -/** - * Polygon - * - * @author cwei - */ -public final class Polygon extends glpoly_t { - - private final static int MAX_POLYS = 20000; - - private final static int MAX_BUFFER_VERTICES = 120000; - - // backup for s1 scrolling - private static float[] s1_old = new float[MAX_VERTICES]; - - private static FloatBuffer buffer = Lib.newFloatBuffer(MAX_BUFFER_VERTICES * STRIDE); - - private static int bufferIndex = 0; - - private static int polyCount = 0; - - private static Polygon[] polyCache = new Polygon[MAX_POLYS]; - - static { - for (int i = 0; i < polyCache.length; i++) { - polyCache[i] = new Polygon(); - } - } - - public static glpoly_t create(int numverts) { - Polygon poly = polyCache[polyCount++]; - poly.clear(); - poly.numverts = numverts; - poly.pos = bufferIndex; - bufferIndex += numverts; - return poly; - } - - static void reset() { - polyCount = 0; - bufferIndex = 0; - } - - public static FloatBuffer getInterleavedBuffer() { - return (FloatBuffer) buffer.rewind(); - } - - private Polygon() { - } - - private final void clear() { - next = null; - chain = null; - numverts = 0; - flags = 0; - } - - // the interleaved buffer has the format: - // textureCoord0 (index 0, 1) - // vertex (index 2, 3, 4) - // textureCoord1 (index 5, 6) - - public final float x(int index) { - return buffer.get((index + pos) * 7 + 2); - } - - public final void x(int index, float value) { - buffer.put((index + pos) * 7 + 2, value); - } - - public final float y(int index) { - return buffer.get((index + pos) * 7 + 3); - } - - public final void y(int index, float value) { - buffer.put((index + pos) * 7 + 3, value); - } - - public final float z(int index) { - return buffer.get((index + pos) * 7 + 4); - } - - public final void z(int index, float value) { - buffer.put((index + pos) * 7 + 4, value); - } - - public final float s1(int index) { - return buffer.get((index + pos) * 7 + 0); - } - - public final void s1(int index, float value) { - buffer.put((index + pos) * 7 + 0, value); - } - - public final float t1(int index) { - return buffer.get((index + pos) * 7 + 1); - } - - public final void t1(int index, float value) { - buffer.put((index + pos) * 7 + 1, value); - } - - public final float s2(int index) { - return buffer.get((index + pos) * 7 + 5); - } - - public final void s2(int index, float value) { - buffer.put((index + pos) * 7 + 5, value); - } - - public final float t2(int index) { - return buffer.get((index + pos) * 7 + 6); - } - - public final void t2(int index, float value) { - buffer.put((index + pos) * 7 + 6, value); - } - - public final void beginScrolling(float scroll) { - int index = pos * 7; - for (int i = 0; i < numverts; i++, index += 7) { - scroll += s1_old[i] = buffer.get(index); - buffer.put(index, scroll); - } - } - - public final void endScrolling() { - int index = pos * 7; - for (int i = 0; i < numverts; i++, index += 7) { - buffer.put(index, s1_old[i]); - } - } -}
\ No newline at end of file diff --git a/src/jake2/render/common/Surf.java b/src/jake2/render/common/Surf.java deleted file mode 100644 index 2847b7c..0000000 --- a/src/jake2/render/common/Surf.java +++ /dev/null @@ -1,1204 +0,0 @@ -/* -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. - -*/ - -// Created on 20.08.2006 by RST. - -// $Id: Surf.java,v 1.2 2006-10-31 14:00:23 salomo Exp $ - -package jake2.render.common; - - -import jake2.Defines; -import jake2.client.*; -import jake2.game.cplane_t; -import jake2.qcommon.Com; -import jake2.render.*; -import jake2.util.*; - -import java.nio.*; -import java.util.Arrays; - -public abstract class Surf extends Draw { - - // GL_RSURF.C: surface-related refresh code - protected float[] modelorg = { 0, 0, 0 }; // relative to viewpoint - - protected msurface_t r_alpha_surfaces; - - protected static final int DYNAMIC_LIGHT_WIDTH = 128; - - protected static final int DYNAMIC_LIGHT_HEIGHT = 128; - - protected static final int LIGHTMAP_BYTES = 4; - - protected static final int LM_BLOCK_WIDTH = 128; - - protected static final int LM_BLOCK_HEIGHT = 128; - - protected int c_visible_lightmaps; - - protected int c_visible_textures; - - protected gllightmapstate_t gl_lms = new gllightmapstate_t(); - - protected static final int GL_LIGHTMAP_FORMAT = ggl.GL_RGBA; - - public static final int MAX_LIGHTMAPS = 128; - - protected byte[] fatvis = new byte[Defines.MAX_MAP_LEAFS / 8]; - - protected lightstyle_t[] lightstyles; - - public static class gllightmapstate_t { - - public int internal_format; - - public int current_lightmap_texture; - - public msurface_t[] lightmap_surfaces = new msurface_t[MAX_LIGHTMAPS]; - - public int[] allocated = new int[LM_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 IntBuffer lightmap_buffer = Lib.newIntBuffer( - LM_BLOCK_WIDTH * LM_BLOCK_HEIGHT, ByteOrder.LITTLE_ENDIAN); - - public gllightmapstate_t() { - for (int i = 0; i < MAX_LIGHTMAPS; i++) - lightmap_surfaces[i] = new msurface_t(); - } - - public void clearLightmapSurfaces() { - for (int i = 0; i < MAX_LIGHTMAPS; i++) - // TODO lightmap_surfaces[i].clear(); - lightmap_surfaces[i] = new msurface_t(); - } - } - - - /** - * LM_InitBlock - */ - protected void LM_InitBlock() { - Arrays.fill(gl_lms.allocated, 0); - } - - - /** - * LM_AllocBlock. - * - */ - protected boolean LM_AllocBlock(int w, int h, pos_t pos) { - int best = LM_BLOCK_HEIGHT; - int x = pos.x; - - int best2; - int i, j; - for (i = 0; i < LM_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 = best = best2; - } - } - - if (best + h > LM_BLOCK_HEIGHT) - return false; - - for (i = 0; i < w; i++) - gl_lms.allocated[x + i] = best + h; - - return true; - } - - /** - * R_TextureAnimation - * - * Returns the proper texture for a given time and base texture - */ - protected 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. - */ - protected void DrawGLPoly(glpoly_t p) { - ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts); - } - - /** - * DrawGLFlowingPoly version that handles scrolling texture - */ - protected void DrawGLFlowingPoly(glpoly_t p) { - float scroll = -64 * ((r_newrefdef.time / 40.0f) - (int) (r_newrefdef.time / 40.0f)); - if (scroll == 0.0f) - scroll = -64.0f; - p.beginScrolling(scroll); - ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts); - p.endScrolling(); - } - - protected abstract void GL_LoadMatrix(); - - /** - * 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. - */ - protected void R_DrawAlphaSurfaces() { - - GL_LoadMatrix(); - - ggl.glEnable(ggl.GL_BLEND); - GL_TexEnv(ggl.GL_MODULATE); - - // the textures are prescaled up for a better lighting range, - // so scale it back down - float intens = gl_state.inverse_intensity; - - ggl.glInterleavedArrays(ggl.GL_T2F_V3F, Polygon.BYTE_STRIDE, globalPolygonInterleavedBuf); - - for (msurface_t 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) - ggl.glColor4f(intens, intens, intens, 0.33f); - else if ((s.texinfo.flags & Defines.SURF_TRANS66) != 0) - ggl.glColor4f(intens, intens, intens, 0.66f); - else - ggl.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.polys); // PGM - else - DrawGLPoly(s.polys); - } - - GL_TexEnv(ggl.GL_REPLACE); - ggl.glColor4f(1, 1, 1, 1); - ggl.glDisable(ggl.GL_BLEND); - - r_alpha_surfaces = null; - } - - /** - * R_DrawTriangleOutlines - */ - protected void R_DrawTriangleOutlines() { - if (gl_showtris.value == 0) - return; - - ggl.glDisable(ggl.GL_TEXTURE_2D); - ggl.glDisable(ggl.GL_DEPTH_TEST); - ggl.glColor4f(1, 1, 1, 1); - - for (int i = 0; i < MAX_LIGHTMAPS; i++) { - for (msurface_t surf = gl_lms.lightmap_surfaces[i]; surf != null; surf = surf.lightmapchain) { - for (glpoly_t p = surf.polys; p != null; p = p.chain) { - for (int j = 2; j < p.numverts; j++) { - ggl.glBegin(ggl.GL_LINE_STRIP); - ggl.glVertex3f(p.x(0), p.y(0), p.z(0)); - ggl.glVertex3f(p.x(j-1), p.y(j-1), p.z(j-1)); - ggl.glVertex3f(p.x(j), p.y(j), p.z(j)); - ggl.glVertex3f(p.x(0), p.y(0), p.z(0)); - ggl.glEnd(); - } - } - } - } - - ggl.glEnable(ggl.GL_DEPTH_TEST); - ggl.glEnable(ggl.GL_TEXTURE_2D); - } - - /** - * R_MarkLeaves - - * - * Mark the leaves and nodes that are in the PVS for the current cluster. - */ - protected void R_MarkLeaves() { - - 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; - } - - byte[] vis = Mod_ClusterPVS(r_viewcluster, r_worldmodel); - - // may have to combine two clusters because of solid water boundaries - if (r_viewcluster2 != r_viewcluster) { - System .arraycopy(vis, 0, fatvis, 0, (r_worldmodel.numleafs + 7) >> 3); - vis = Mod_ClusterPVS(r_viewcluster2, r_worldmodel); - c = (r_worldmodel.numleafs + 31) >> 5; - c <<= 2; - - for (int k = 0; k < c; k+=4) { - fatvis[k] |= vis[k]; - fatvis[k + 1] |= vis[k + 1]; - fatvis[k + 2] |= vis[k + 2]; - fatvis[k + 3] |= vis[k + 3]; - } - - 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); - } - } - } - - // direct buffer - protected IntBuffer temp = Lib.newIntBuffer(128 * 128,ByteOrder.LITTLE_ENDIAN); - - protected IntBuffer temp2 = Lib.newIntBuffer(34 * 34, ByteOrder.LITTLE_ENDIAN); - - /* - * new buffers for vertex array handling - */ - protected static FloatBuffer globalPolygonInterleavedBuf = Polygon.getInterleavedBuffer(); - - protected static FloatBuffer globalPolygonTexCoord1Buf = null; - - static { - globalPolygonInterleavedBuf.position(Polygon.STRIDE - 2); - globalPolygonTexCoord1Buf = globalPolygonInterleavedBuf.slice(); - globalPolygonInterleavedBuf.position(0); - }; - - protected abstract void EmitWaterPolys(msurface_t s); - protected abstract void R_BuildLightMap(msurface_t fa, IntBuffer temp22, int smax); - protected abstract void R_SetCacheState(msurface_t fa); - protected abstract void R_MarkLights(dlight_t lt, int i, mnode_t mnode_t); - protected abstract void R_AddSkySurface(msurface_t s); - protected abstract void R_DrawSkyBox(); - protected abstract void R_ClearSkyBox(); - - /** - * R_RotateForEntity - */ - protected final void R_RotateForEntity(entity_t e) { - ggl.glTranslatef(e.origin[0], e.origin[1], e.origin[2]); - - ggl.glRotatef(e.angles[1], 0, 0, 1); - ggl.glRotatef(-e.angles[0], 0, 1, 0); - ggl.glRotatef(-e.angles[2], 1, 0, 0); - } - - - /** - *R_RenderBrushPoly ================ - */ - protected 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(ggl.GL_MODULATE); - ggl.glColor4f(gl_state.inverse_intensity, gl_state.inverse_intensity, gl_state.inverse_intensity, 1.0F); - EmitWaterPolys(fa); - GL_TexEnv(ggl.GL_REPLACE); - - return; - } else { - GL_Bind(image.texnum); - GL_TexEnv(ggl.GL_REPLACE); - } - - // ====== - // PGM - if ((fa.texinfo.flags & Defines.SURF_FLOWING) != 0) - DrawGLFlowingPoly(fa.polys); - else - DrawGLPoly(fa.polys); - // PGM - // ====== - - // ersetzt goto - boolean gotoDynamic = false; - - // check for lightmap modification - for (maps = 0; maps < Defines.MAXLIGHTMAPS - && fa.styles[maps] != (byte) 255; maps++) { - if (r_newrefdef.lightstyles[fa.styles[maps] & 0xFF].white != fa.cached_light[maps]) { - gotoDynamic = true; - break; - } - } - - // this is a hack from cwei - if (maps == 4) - maps--; - - // dynamic this frame or dynamic previously - if (gotoDynamic || (fa.dlightframe == r_framecount)) { - // label dynamic: - if (gl_dynamic.value != 0) { - if ((fa.texinfo.flags & (Defines.SURF_SKY - | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP)) == 0) { - is_dynamic = true; - } - } - } - - if (is_dynamic) { - if (((fa.styles[maps] & 0xFF) >= 32 || fa.styles[maps] == 0) - && (fa.dlightframe != r_framecount)) { - // ist ersetzt durch temp2: unsigned temp[34*34]; - int smax, tmax; - - smax = (fa.extents[0] >> 4) + 1; - tmax = (fa.extents[1] >> 4) + 1; - - R_BuildLightMap(fa, temp2, smax); - R_SetCacheState(fa); - - GL_Bind(gl_state.lightmap_textures + fa.lightmaptexturenum); - - ggl.glTexSubImage2D(ggl.GL_TEXTURE_2D, 0, fa.light_s, fa.light_t, - smax, tmax, GL_LIGHTMAP_FORMAT, ggl.GL_UNSIGNED_BYTE, - temp2); - - 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; - } - } - - IntBuffer dummy = newIntBuffer(128 * 128); - - /** - * GL_BeginBuildingLightmaps. - */ - protected void GL_BeginBuildingLightmaps(model_t m) { - - if (lightstyles == null) { - lightstyles = new lightstyle_t[Defines.MAX_LIGHTSTYLES]; - for (int i = 0; i < lightstyles.length; i++) { - lightstyles[i] = new lightstyle_t(); - } - } - - 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 (int 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 = Base.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 = ggl.GL_INTENSITY8; - } else if (format == 'L') { - gl_lms.internal_format = ggl.GL_LUMINANCE8; - } else { - gl_lms.internal_format = gl_tex_solid_format; - } - - /* - * * initialize the dynamic lightmap texture - */ - GL_Bind(gl_state.lightmap_textures + 0); - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, ggl.GL_LINEAR); - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, ggl.GL_LINEAR); - ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, gl_lms.internal_format, - LM_BLOCK_WIDTH, LM_BLOCK_HEIGHT, 0, GL_LIGHTMAP_FORMAT, - ggl.GL_UNSIGNED_BYTE, dummy); - } - - - /** - * GL_EndBuildingLightmaps. - */ - protected void GL_EndBuildingLightmaps() { - LM_UploadBlock(false); - GL_EnableMultitexture(false); - } - - /** - * DrawTextureChains. - */ - protected void DrawTextureChains() { - int i; - msurface_t s; - image_t image; - - c_visible_textures = 0; - - 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(ggl.GL_REPLACE); - } - - protected void GL_RenderLightmappedPoly(msurface_t surf) { - int map = 0; - - image_t image = R_TextureAnimation(surf.texinfo); - boolean is_dynamic = false; - int lmtex = surf.lightmaptexturenum; - glpoly_t p; - - // ersetzt goto - boolean gotoDynamic = false; - - 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]) { - gotoDynamic = true; - break; - } - } - - // this is a hack from cwei - if (map == 4) - map--; - - // dynamic this frame or dynamic previously - if (gotoDynamic || (surf.dlightframe == r_framecount)) { - // label dynamic: - if (gl_dynamic.value != 0) { - if ((surf.texinfo.flags & (Defines.SURF_SKY - | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP)) == 0) { - is_dynamic = true; - } - } - } - - if (is_dynamic) { - // ist raus gezogen worden int[] temp = new int[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, temp, smax); - R_SetCacheState(surf); - - GL_MBind(GL_TEXTURE1, gl_state.lightmap_textures - + surf.lightmaptexturenum); - - lmtex = surf.lightmaptexturenum; - - ggl.glTexSubImage2D(ggl.GL_TEXTURE_2D, 0, surf.light_s, - surf.light_t, smax, tmax, GL_LIGHTMAP_FORMAT, - ggl.GL_UNSIGNED_BYTE, temp); - - } else { - smax = (surf.extents[0] >> 4) + 1; - tmax = (surf.extents[1] >> 4) + 1; - - R_BuildLightMap(surf, temp, smax); - - GL_MBind(GL_TEXTURE1, gl_state.lightmap_textures + 0); - - lmtex = 0; - - ggl.glTexSubImage2D(ggl.GL_TEXTURE_2D, 0, surf.light_s, - surf.light_t, smax, tmax, GL_LIGHTMAP_FORMAT, - ggl.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) { - p.beginScrolling(scroll); - ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts); - p.endScrolling(); - } - } else { - for (p = surf.polys; p != null; p = p.chain) { - ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts); - } - } - // 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) { - p.beginScrolling(scroll); - ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts); - p.endScrolling(); - } - } else { - // PGM - // ========== - for (p = surf.polys; p != null; p = p.chain) { - ggl.glDrawArrays(ggl.GL_POLYGON, p.pos, p.numverts); - } - - // ========== - // 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]); - } - } - - int psurfp = currentmodel.firstmodelsurface; - msurface_t[] surfaces; - surfaces = currentmodel.surfaces; - - if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) { - ggl.glEnable(ggl.GL_BLEND); - ggl.glColor4f(1, 1, 1, 0.25f); - GL_TexEnv(ggl.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 < -Base.BACKFACE_EPSILON)) - || ((psurf.flags & Defines.SURF_PLANEBACK) == 0 && (dot > Base.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 ((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) { - ggl.glDisable(ggl.GL_BLEND); - ggl.glColor4f(1, 1, 1, 1); - GL_TexEnv(ggl.GL_REPLACE); - } - } - - /** - * R_DrawBrushModel. - */ - protected void R_DrawBrushModel(entity_t e) { - if (currentmodel.nummodelsurfaces == 0) - return; - - currententity = e; - gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1; - - float[] mins = Vec3Cache.get(); - float[] maxs = Vec3Cache.get(); - boolean rotated; - if (e.angles[0] != 0 || e.angles[1] != 0 || e.angles[2] != 0) { - rotated = true; - for (int i = 0; i < 3; i++) { - mins[i] = e.origin[i] - currentmodel.radius; - maxs[i] = e.origin[i] + currentmodel.radius; - } - } else { - rotated = false; - Math3D.VectorAdd(e.origin, currentmodel.mins, mins); - Math3D.VectorAdd(e.origin, currentmodel.maxs, maxs); - } - - if (R_CullBox(mins, maxs)) { - Vec3Cache.release(2); // mins, maxs - return; - } - - Vec3Cache.release(2); // mins, maxs - - ggl.glColor3f(1, 1, 1); - - Math3D.VectorSubtract(r_newrefdef.vieworg, e.origin, modelorg); - if (rotated) { - float[] temp = Vec3Cache.get(); - float[] forward = Vec3Cache.get(); - float[] right = Vec3Cache.get(); - float[] up = Vec3Cache.get(); - - 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); - - Vec3Cache.release(4); // temp, forward, right, up - } - - ggl.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(ggl.GL_REPLACE); - ggl.glInterleavedArrays(ggl.GL_T2F_V3F, Polygon.BYTE_STRIDE, - globalPolygonInterleavedBuf); - GL_SelectTexture(GL_TEXTURE1); - GL_TexEnv(ggl.GL_MODULATE); - ggl.glTexCoordPointer(2, ggl.GL_FLOAT, Polygon.BYTE_STRIDE, - globalPolygonTexCoord1Buf); - ggl.glEnableClientState(ggl.GL_TEXTURE_COORD_ARRAY); - - R_DrawInlineBModel(); - - ggl.glClientActiveTextureARB(GL_TEXTURE1); - ggl.glDisableClientState(ggl.GL_TEXTURE_COORD_ARRAY); - - GL_EnableMultitexture(false); - - ggl.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 = 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 ((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. - */ - private final entity_t worldEnt = new entity_t(); - - protected void R_DrawWorld() { - - if (r_drawworld.value == 0) - return; - - if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) - return; - - currentmodel = r_worldmodel; - - Math3D.VectorCopy(r_newrefdef.vieworg, modelorg); - - entity_t ent = worldEnt; - // auto cycle the world frame for texture animation - ent.clear(); - ent.frame = (int) (r_newrefdef.time * 2); - currententity = ent; - - gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1; - - ggl.glColor3f(1, 1, 1); - - - // TODO wird bei multitexture nicht gebraucht - //gl_lms.clearLightmapSurfaces(); - - R_ClearSkyBox(); - - GL_EnableMultitexture(true); - - GL_SelectTexture(GL_TEXTURE0); - GL_TexEnv(ggl.GL_REPLACE); - ggl.glInterleavedArrays(ggl.GL_T2F_V3F, Polygon.BYTE_STRIDE, - globalPolygonInterleavedBuf); - GL_SelectTexture(GL_TEXTURE1); - ggl.glTexCoordPointer(2, ggl.GL_FLOAT, Polygon.BYTE_STRIDE, - globalPolygonTexCoord1Buf); - ggl.glEnableClientState(ggl.GL_TEXTURE_COORD_ARRAY); - - if (gl_lightmap.value != 0) - GL_TexEnv(ggl.GL_REPLACE); - else - GL_TexEnv(ggl.GL_MODULATE); - - R_RecursiveWorldNode(r_worldmodel.nodes[0]); // root node - - ggl.glClientActiveTextureARB(GL_TEXTURE1); - ggl.glDisableClientState(ggl.GL_TEXTURE_COORD_ARRAY); - - GL_EnableMultitexture(false); - - DrawTextureChains(); - R_DrawSkyBox(); - R_DrawTriangleOutlines(); - } - - - - - /** - * LIGHTMAP ALLOCATION - * - */ - - protected 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); - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MIN_FILTER, - ggl.GL_LINEAR); - ggl.glTexParameterf(ggl.GL_TEXTURE_2D, ggl.GL_TEXTURE_MAG_FILTER, - ggl.GL_LINEAR); - - gl_lms.lightmap_buffer.rewind(); - if (dynamic) { - int i; - - for (i = 0; i < LM_BLOCK_WIDTH; i++) { - if (gl_lms.allocated[i] > height) - height = gl_lms.allocated[i]; - } - - ggl.glTexSubImage2D(ggl.GL_TEXTURE_2D, 0, 0, 0, LM_BLOCK_WIDTH, height, - GL_LIGHTMAP_FORMAT, ggl.GL_UNSIGNED_BYTE, - gl_lms.lightmap_buffer); - } else { - ggl.glTexImage2D(ggl.GL_TEXTURE_2D, 0, gl_lms.internal_format, - LM_BLOCK_WIDTH, LM_BLOCK_HEIGHT, 0, GL_LIGHTMAP_FORMAT, - ggl.GL_UNSIGNED_BYTE, gl_lms.lightmap_buffer); - if (++gl_lms.current_lightmap_texture == MAX_LIGHTMAPS) - Com.Error(Defines.ERR_DROP, - "LM_UploadBlock() - MAX_LIGHTMAPS exceeded\n"); - - //debugLightmap(gl_lms.lightmap_buffer, 128, 128, 4); - } - } - - - /** - * GL_BuildPolygonFromSurface. - */ - protected void GL_BuildPolygonFromSurface(msurface_t fa) { - int i, lindex, lnumverts; - medge_t[] pedges; - medge_t r_pedge; - float[] vec; - float s, t; - // reconstruct the polygon - pedges = currentmodel.edges; - lnumverts = fa.numedges; - - // - // draw texture - // - glpoly_t poly = Polygon.create(lnumverts); - - poly.next = fa.polys; - poly.flags = fa.flags; - fa.polys = poly; - - 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; - - poly.x(i, vec[0]); - poly.y(i, vec[1]); - poly.z(i, vec[2]); - poly.s1(i, s); - poly.t1(i, 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 /= LM_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 /= LM_BLOCK_HEIGHT * 16; // fa.texinfo.texture.height; - - poly.s2(i, s); - poly.t2(i, t); - } - } - - /** - * GL_CreateSurfaceLightmap. - */ - protected void GL_CreateSurfaceLightmap(msurface_t surf) { - int smax, tmax; - IntBuffer 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)) { - Com.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.position(surf.light_t * LM_BLOCK_WIDTH + surf.light_s); - - R_SetCacheState(surf); - R_BuildLightMap(surf, base.slice(), LM_BLOCK_WIDTH); - } -} diff --git a/src/jake2/render/common/Warp.java b/src/jake2/render/common/Warp.java deleted file mode 100644 index 514c9fa..0000000 --- a/src/jake2/render/common/Warp.java +++ /dev/null @@ -1,674 +0,0 @@ -/* -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. - -*/ - -// Created on 20.08.2006 by RST. -// $Id: Warp.java,v 1.2 2006-10-31 14:00:23 salomo Exp $ - -package jake2.render.common; - -import jake2.Defines; -import jake2.Globals; -import jake2.qcommon.Com; -import jake2.render.*; -import jake2.util.Math3D; -import jake2.util.Vec3Cache; - - -public abstract class Warp extends Surf { - // warpsin.h - public static final float[] SIN = { 0f, 0.19633f, 0.392541f, 0.588517f, - 0.784137f, 0.979285f, 1.17384f, 1.3677f, 1.56072f, 1.75281f, - 1.94384f, 2.1337f, 2.32228f, 2.50945f, 2.69512f, 2.87916f, - 3.06147f, 3.24193f, 3.42044f, 3.59689f, 3.77117f, 3.94319f, - 4.11282f, 4.27998f, 4.44456f, 4.60647f, 4.76559f, 4.92185f, - 5.07515f, 5.22538f, 5.37247f, 5.51632f, 5.65685f, 5.79398f, - 5.92761f, 6.05767f, 6.18408f, 6.30677f, 6.42566f, 6.54068f, - 6.65176f, 6.75883f, 6.86183f, 6.9607f, 7.05537f, 7.14579f, - 7.23191f, 7.31368f, 7.39104f, 7.46394f, 7.53235f, 7.59623f, - 7.65552f, 7.71021f, 7.76025f, 7.80562f, 7.84628f, 7.88222f, - 7.91341f, 7.93984f, 7.96148f, 7.97832f, 7.99036f, 7.99759f, 8f, - 7.99759f, 7.99036f, 7.97832f, 7.96148f, 7.93984f, 7.91341f, - 7.88222f, 7.84628f, 7.80562f, 7.76025f, 7.71021f, 7.65552f, - 7.59623f, 7.53235f, 7.46394f, 7.39104f, 7.31368f, 7.23191f, - 7.14579f, 7.05537f, 6.9607f, 6.86183f, 6.75883f, 6.65176f, - 6.54068f, 6.42566f, 6.30677f, 6.18408f, 6.05767f, 5.92761f, - 5.79398f, 5.65685f, 5.51632f, 5.37247f, 5.22538f, 5.07515f, - 4.92185f, 4.76559f, 4.60647f, 4.44456f, 4.27998f, 4.11282f, - 3.94319f, 3.77117f, 3.59689f, 3.42044f, 3.24193f, 3.06147f, - 2.87916f, 2.69512f, 2.50945f, 2.32228f, 2.1337f, 1.94384f, - 1.75281f, 1.56072f, 1.3677f, 1.17384f, 0.979285f, 0.784137f, - 0.588517f, 0.392541f, 0.19633f, 9.79717e-16f, -0.19633f, - -0.392541f, -0.588517f, -0.784137f, -0.979285f, -1.17384f, - -1.3677f, -1.56072f, -1.75281f, -1.94384f, -2.1337f, -2.32228f, - -2.50945f, -2.69512f, -2.87916f, -3.06147f, -3.24193f, -3.42044f, - -3.59689f, -3.77117f, -3.94319f, -4.11282f, -4.27998f, -4.44456f, - -4.60647f, -4.76559f, -4.92185f, -5.07515f, -5.22538f, -5.37247f, - -5.51632f, -5.65685f, -5.79398f, -5.92761f, -6.05767f, -6.18408f, - -6.30677f, -6.42566f, -6.54068f, -6.65176f, -6.75883f, -6.86183f, - -6.9607f, -7.05537f, -7.14579f, -7.23191f, -7.31368f, -7.39104f, - -7.46394f, -7.53235f, -7.59623f, -7.65552f, -7.71021f, -7.76025f, - -7.80562f, -7.84628f, -7.88222f, -7.91341f, -7.93984f, -7.96148f, - -7.97832f, -7.99036f, -7.99759f, -8f, -7.99759f, -7.99036f, - -7.97832f, -7.96148f, -7.93984f, -7.91341f, -7.88222f, -7.84628f, - -7.80562f, -7.76025f, -7.71021f, -7.65552f, -7.59623f, -7.53235f, - -7.46394f, -7.39104f, -7.31368f, -7.23191f, -7.14579f, -7.05537f, - -6.9607f, -6.86183f, -6.75883f, -6.65176f, -6.54068f, -6.42566f, - -6.30677f, -6.18408f, -6.05767f, -5.92761f, -5.79398f, -5.65685f, - -5.51632f, -5.37247f, -5.22538f, -5.07515f, -4.92185f, -4.76559f, - -4.60647f, -4.44456f, -4.27998f, -4.11282f, -3.94319f, -3.77117f, - -3.59689f, -3.42044f, -3.24193f, -3.06147f, -2.87916f, -2.69512f, - -2.50945f, -2.32228f, -2.1337f, -1.94384f, -1.75281f, -1.56072f, - -1.3677f, -1.17384f, -0.979285f, -0.784137f, -0.588517f, - -0.392541f, -0.19633f }; - - String skyname; - - protected float skyrotate; - - protected float[] skyaxis = { 0, 0, 0 }; - - protected image_t[] sky_images = new image_t[6]; - - protected msurface_t warpface; - - protected static final int SUBDIVIDE_SIZE = 64; - - /** - * BoundPoly - * - */ - protected void BoundPoly(int numverts, float[][] verts, float[] mins, float[] maxs) { - mins[0] = mins[1] = mins[2] = 9999; - maxs[0] = maxs[1] = maxs[2] = -9999; - - int j; - float[] v; - for (int i = 0; i < numverts; i++) { - v = verts[i]; - for (j = 0; j < 3; j++) { - if (v[j] < mins[j]) - mins[j] = v[j]; - if (v[j] > maxs[j]) - maxs[j] = v[j]; - } - } - } - - /** - * SubdividePolygon - * - */ - protected void SubdividePolygon(int numverts, float[][] verts) { - int i, j, k; - float m; - float[][] front = new float[64][3]; - float[][] back = new float[64][3]; - - int f, b; - float[] dist = new float[64]; - float frac; - - if (numverts > 60) - Com.Error(Defines.ERR_DROP, "numverts = " + numverts); - - float[] mins = Vec3Cache.get(); - float[] maxs = Vec3Cache.get(); - - BoundPoly(numverts, verts, mins, maxs); - float[] v; - // x,y und z - for (i = 0; i < 3; i++) { - m = (mins[i] + maxs[i]) * 0.5f; - m = SUBDIVIDE_SIZE * (float) Math.floor(m / SUBDIVIDE_SIZE + 0.5f); - if (maxs[i] - m < 8) - continue; - if (m - mins[i] < 8) - continue; - - // cut it - for (j = 0; j < numverts; j++) { - dist[j] = verts[j][i] - m; - } - - // wrap cases - dist[j] = dist[0]; - - Math3D.VectorCopy(verts[0], verts[numverts]); - - f = b = 0; - for (j = 0; j < numverts; j++) { - v = verts[j]; - if (dist[j] >= 0) { - Math3D.VectorCopy(v, front[f]); - f++; - } - if (dist[j] <= 0) { - Math3D.VectorCopy(v, back[b]); - b++; - } - if (dist[j] == 0 || dist[j + 1] == 0) - continue; - - if ((dist[j] > 0) != (dist[j + 1] > 0)) { - // clip point - frac = dist[j] / (dist[j] - dist[j + 1]); - for (k = 0; k < 3; k++) - front[f][k] = back[b][k] = v[k] + frac - * (verts[j + 1][k] - v[k]); - - f++; - b++; - } - } - - SubdividePolygon(f, front); - SubdividePolygon(b, back); - - Vec3Cache.release(2); // mins, maxs - return; - } - - Vec3Cache.release(2); // mins, maxs - - // add a point in the center to help keep warp valid - - // wird im Konstruktor erschlagen - // poly = Hunk_Alloc (sizeof(glpoly_t) + ((numverts-4)+2) * - // VERTEXSIZE*sizeof(float)); - - // init polys - glpoly_t poly = Polygon.create(numverts + 2); - - poly.next = warpface.polys; - warpface.polys = poly; - - float[] total = Vec3Cache.get(); - Math3D.VectorClear(total); - float total_s = 0; - float total_t = 0; - float s, t; - for (i = 0; i < numverts; i++) { - poly.x(i + 1, verts[i][0]); - poly.y(i + 1, verts[i][1]); - poly.z(i + 1, verts[i][2]); - s = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[0]); - t = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[1]); - - total_s += s; - total_t += t; - Math3D.VectorAdd(total, verts[i], total); - - poly.s1(i + 1, s); - poly.t1(i + 1, t); - } - - float scale = 1.0f / numverts; - poly.x(0, total[0] * scale); - poly.y(0, total[1] * scale); - poly.z(0, total[2] * scale); - poly.s1(0, total_s * scale); - poly.t1(0, total_t * scale); - - poly.x(i + 1, poly.x(1)); - poly.y(i + 1, poly.y(1)); - poly.z(i + 1, poly.z(1)); - poly.s1(i + 1, poly.s1(1)); - poly.t1(i + 1, poly.t1(1)); - poly.s2(i + 1, poly.s2(1)); - poly.t2(i + 1, poly.t2(1)); - - Vec3Cache.release(); // total - } - - private final float[][] tmpVerts = new float[64][3]; - - /** - * GL_SubdivideSurface Breaks a polygon up along axial 64 unit boundaries so - * that turbulent and sky warps can be done reasonably. - */ - protected void GL_SubdivideSurface(msurface_t fa) { - float[][] verts = tmpVerts; - float[] vec; - warpface = fa; - // - // convert edges back to a normal polygon - // - int numverts = 0; - for (int i = 0; i < fa.numedges; i++) { - int lindex = loadmodel.surfedges[fa.firstedge + i]; - - if (lindex > 0) - vec = loadmodel.vertexes[loadmodel.edges[lindex].v[0]].position; - else - vec = loadmodel.vertexes[loadmodel.edges[-lindex].v[1]].position; - Math3D.VectorCopy(vec, verts[numverts]); - numverts++; - } - SubdividePolygon(numverts, verts); - } - - protected static final float TURBSCALE = (float) (256.0f / (2 * Math.PI)); - - float[][] skyclip = { { 1, 1, 0 }, { 1, -1, 0 }, { 0, -1, 1 }, { 0, 1, 1 }, { 1, 0, 1 }, { -1, 0, 1 } }; - - protected int c_sky; - - // 1 = s, 2 = t, 3 = 2048 - protected int[][] st_to_vec = { - { 3, -1, 2 }, { -3, 1, 2 }, - { 1, 3, 2 }, { -1, -3, 2 }, - { -2, -1, 3 }, // 0 degrees yaw, look straight up - { 2, -1, -3 } // look straight down - }; - - protected int[][] vec_to_st = { - { -2, 3, 1 }, { 2, 3, -1 }, - { 1, 3, 2 }, { -1, 3, -2 }, - { -2, -1, 3 }, { -2, 1, -3 } - }; - - protected float[][] skymins = new float[2][6]; - - protected float[][] skymaxs = new float[2][6]; - - protected float sky_min, sky_max; - - protected static final float ON_EPSILON = 0.1f; // point on plane side epsilon - - protected static final int MAX_CLIP_VERTS = 64; - - protected static final int SIDE_BACK = 1; - - protected static final int SIDE_FRONT = 0; - - protected static final int SIDE_ON = 2; - - protected float[] dists = new float[MAX_CLIP_VERTS]; - - protected int[] sides = new int[MAX_CLIP_VERTS]; - - protected float[][][][] newv = new float[6][2][MAX_CLIP_VERTS][3]; - - /** - * ClipSkyPolygon - * - * @param nump - * @param vecs - * @param stage - */ - protected void ClipSkyPolygon(int nump, float[][] vecs, int stage) { - if (nump > MAX_CLIP_VERTS - 2) - Com.Error(Defines.ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS"); - if (stage == 6) { // fully clipped, so draw it - DrawSkyPolygon(nump, vecs); - return; - } - - boolean front = false; - boolean back = false; - float[] norm = skyclip[stage]; - - int i; - float d; - for (i = 0; i < nump; i++) { - d = Math3D.DotProduct(vecs[i], norm); - if (d > ON_EPSILON) { - front = true; - sides[i] = SIDE_FRONT; - } else if (d < -ON_EPSILON) { - back = true; - sides[i] = SIDE_BACK; - } else - sides[i] = SIDE_ON; - dists[i] = d; - } - - if (!front || !back) { // not clipped - ClipSkyPolygon(nump, vecs, stage + 1); - return; - } - - // clip it - sides[i] = sides[0]; - dists[i] = dists[0]; - Math3D.VectorCopy(vecs[0], vecs[i]); - - int newc0 = 0; - int newc1 = 0; - float[] v; - float e; - int j; - for (i = 0; i < nump; i++) { - v = vecs[i]; - switch (sides[i]) { - case SIDE_FRONT: - Math3D.VectorCopy(v, newv[stage][0][newc0]); - newc0++; - break; - case SIDE_BACK: - Math3D.VectorCopy(v, newv[stage][1][newc1]); - newc1++; - break; - case SIDE_ON: - Math3D.VectorCopy(v, newv[stage][0][newc0]); - newc0++; - Math3D.VectorCopy(v, newv[stage][1][newc1]); - newc1++; - break; - } - - if (sides[i] == SIDE_ON || sides[i + 1] == SIDE_ON - || sides[i + 1] == sides[i]) - continue; - - d = dists[i] / (dists[i] - dists[i + 1]); - for (j = 0; j < 3; j++) { - e = v[j] + d * (vecs[i + 1][j] - v[j]); - newv[stage][0][newc0][j] = e; - newv[stage][1][newc1][j] = e; - } - newc0++; - newc1++; - } - - // continue - ClipSkyPolygon(newc0, newv[stage][0], stage + 1); - ClipSkyPolygon(newc1, newv[stage][1], stage + 1); - } - - protected float[][] verts = new float[MAX_CLIP_VERTS][3]; - - - - // stack variable - private final float[] v = { 0, 0, 0 }; - - private final float[] av = { 0, 0, 0 }; - - /** - * DrawSkyPolygon - * - */ - protected void DrawSkyPolygon(int nump, float[][] vecs) { - c_sky++; - // decide which face it maps to - Math3D.VectorCopy(Globals.vec3_origin, v); - int i, axis; - for (i = 0; i < nump; i++) { - Math3D.VectorAdd(vecs[i], v, v); - } - av[0] = Math.abs(v[0]); - av[1] = Math.abs(v[1]); - av[2] = Math.abs(v[2]); - if (av[0] > av[1] && av[0] > av[2]) { - if (v[0] < 0) - axis = 1; - else - axis = 0; - } else if (av[1] > av[2] && av[1] > av[0]) { - if (v[1] < 0) - axis = 3; - else - axis = 2; - } else { - if (v[2] < 0) - axis = 5; - else - axis = 4; - } - - // project new texture coords - float s, t, dv; - int j; - for (i = 0; i < nump; i++) { - j = vec_to_st[axis][2]; - if (j > 0) - dv = vecs[i][j - 1]; - else - dv = -vecs[i][-j - 1]; - if (dv < 0.001f) - continue; // don't divide by zero - j = vec_to_st[axis][0]; - if (j < 0) - s = -vecs[i][-j - 1] / dv; - else - s = vecs[i][j - 1] / dv; - j = vec_to_st[axis][1]; - if (j < 0) - t = -vecs[i][-j - 1] / dv; - else - t = vecs[i][j - 1] / dv; - - if (s < skymins[0][axis]) - skymins[0][axis] = s; - if (t < skymins[1][axis]) - skymins[1][axis] = t; - if (s > skymaxs[0][axis]) - skymaxs[0][axis] = s; - if (t > skymaxs[1][axis]) - skymaxs[1][axis] = t; - } - } - - /** - * R_AddSkySurface - */ - protected void R_AddSkySurface(msurface_t fa) { - // calculate vertex values for sky box - for (glpoly_t p = fa.polys; p != null; p = p.next) { - for (int i = 0; i < p.numverts; i++) { - verts[i][0] = p.x(i) - r_origin[0]; - verts[i][1] = p.y(i) - r_origin[1]; - verts[i][2] = p.z(i) - r_origin[2]; - } - ClipSkyPolygon(p.numverts, verts, 0); - } - } - - /** - * R_ClearSkyBox - */ - protected void R_ClearSkyBox() { - float[] skymins0 = skymins[0]; - float[] skymins1 = skymins[1]; - float[] skymaxs0 = skymaxs[0]; - float[] skymaxs1 = skymaxs[1]; - - for (int i = 0; i < 6; i++) { - skymins0[i] = skymins1[i] = 9999; - skymaxs0[i] = skymaxs1[i] = -9999; - } - } - - - protected int[] skytexorder = { 0, 2, 1, 3, 4, 5 }; - - // 3dstudio environment map names - protected String[] suf = { "rt", "bk", "lf", "ft", "up", "dn" }; - - /** - * R_SetSky - * - */ - protected void R_SetSky(String name, float rotate, float[] axis) { - assert (axis.length == 3) : "vec3_t bug"; - String pathname; - skyname = name; - - skyrotate = rotate; - Math3D.VectorCopy(axis, skyaxis); - - for (int i = 0; i < 6; i++) { - // chop down rotating skies for less memory - if (gl_skymip.value != 0 || skyrotate != 0) - gl_picmip.value++; - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0) { - // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.pcx", - // skyname, suf[i]); - pathname = "env/" + skyname + suf[i] + ".pcx"; - } else { - // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.tga", - // skyname, suf[i]); - pathname = "env/" + skyname + suf[i] + ".tga"; - } - - sky_images[i] = GL_FindImage(pathname, Base.it_sky); - - if (sky_images[i] == null) - sky_images[i] = r_notexture; - - if (gl_skymip.value != 0 || skyrotate != 0) { // take less memory - gl_picmip.value--; - sky_min = 1.0f / 256; - sky_max = 255.0f / 256; - } else { - sky_min = 1.0f / 512; - sky_max = 511.0f / 512; - } - } - } - - /** - * EmitWaterPolys - - * Does a water warp on the pre-fragmented glpoly_t chain. - */ - public void EmitWaterPolys(msurface_t fa) { - glpoly_t p, bp; - float s = 0; - float t = 0; - float os, ot; - float scroll; - float rdt = r_newrefdef.time; - - if ((fa.texinfo.flags & Defines.SURF_FLOWING) != 0) - scroll = -64 * ((r_newrefdef.time * 0.5f) - (int) (r_newrefdef.time * 0.5f)); - else - scroll = 0; - - for (bp = fa.polys; bp != null; bp = bp.next) { - p = bp; - - ggl.glBegin(ggl.GL_TRIANGLE_FAN); - for (int 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); - - ggl.glTexCoord2f(s, t); - ggl.glVertex3f(p.x(i), p.y(i), p.z(i)); - } - ggl.glEnd(); - } - } - - // stack variable - private final float[] v1 = {0, 0, 0}; - private final float[] b = {0, 0, 0}; - /** - * MakeSkyVec - * @param s - * @param t - * @param axis - */ - protected void MakeSkyVec(float s, float t, int axis) - { - b[0] = s*2300; - b[1] = t*2300; - b[2] = 2300; - - int j, k; - for (j=0 ; j<3 ; j++) - { - k = st_to_vec[axis][j]; - if (k < 0) - v1[j] = -b[-k - 1]; - else - v1[j] = b[k - 1]; - } - - // avoid bilerp seam - s = (s + 1) * 0.5f; - t = (t + 1) * 0.5f; - - if (s < sky_min) - s = sky_min; - else if (s > sky_max) - s = sky_max; - if (t < sky_min) - t = sky_min; - else if (t > sky_max) - t = sky_max; - - t = 1.0f - t; - ggl.glTexCoord2f (s, t); - ggl.glVertex3f(v1[0], v1[1], v1[2]); - } - - /* - * ============== R_DrawSkyBox ============== - */ - protected 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 - } - - ggl.glPushMatrix(); - ggl.glTranslatef(r_origin[0], r_origin[1], r_origin[2]); - ggl.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); - - ggl.glBegin(ggl.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); - ggl.glEnd(); - } - ggl.glPopMatrix(); - } -} diff --git a/src/jake2/render/fast/Anorms.java b/src/jake2/render/fast/Anorms.java new file mode 100644 index 0000000..2391049 --- /dev/null +++ b/src/jake2/render/fast/Anorms.java @@ -0,0 +1,219 @@ +/* + * Anorms.java + * Copyright (C) 2003 + * + * $Id: Anorms.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +/** + * Anorms + * + * @author cwei + */ +public interface Anorms { + + final float[][] VERTEXNORMALS = { + {-0.525731f, 0.000000f, 0.850651f}, + {-0.442863f, 0.238856f, 0.864188f}, + {-0.295242f, 0.000000f, 0.955423f}, + {-0.309017f, 0.500000f, 0.809017f}, + {-0.162460f, 0.262866f, 0.951056f}, + {0.000000f, 0.000000f, 1.000000f}, + {0.000000f, 0.850651f, 0.525731f}, + {-0.147621f, 0.716567f, 0.681718f}, + {0.147621f, 0.716567f, 0.681718f}, + {0.000000f, 0.525731f, 0.850651f}, + {0.309017f, 0.500000f, 0.809017f}, + {0.525731f, 0.000000f, 0.850651f}, + {0.295242f, 0.000000f, 0.955423f}, + {0.442863f, 0.238856f, 0.864188f}, + {0.162460f, 0.262866f, 0.951056f}, + {-0.681718f, 0.147621f, 0.716567f}, + {-0.809017f, 0.309017f, 0.500000f}, + {-0.587785f, 0.425325f, 0.688191f}, + {-0.850651f, 0.525731f, 0.000000f}, + {-0.864188f, 0.442863f, 0.238856f}, + {-0.716567f, 0.681718f, 0.147621f}, + {-0.688191f, 0.587785f, 0.425325f}, + {-0.500000f, 0.809017f, 0.309017f}, + {-0.238856f, 0.864188f, 0.442863f}, + {-0.425325f, 0.688191f, 0.587785f}, + {-0.716567f, 0.681718f, -0.147621f}, + {-0.500000f, 0.809017f, -0.309017f}, + {-0.525731f, 0.850651f, 0.000000f}, + {0.000000f, 0.850651f, -0.525731f}, + {-0.238856f, 0.864188f, -0.442863f}, + {0.000000f, 0.955423f, -0.295242f}, + {-0.262866f, 0.951056f, -0.162460f}, + {0.000000f, 1.000000f, 0.000000f}, + {0.000000f, 0.955423f, 0.295242f}, + {-0.262866f, 0.951056f, 0.162460f}, + {0.238856f, 0.864188f, 0.442863f}, + {0.262866f, 0.951056f, 0.162460f}, + {0.500000f, 0.809017f, 0.309017f}, + {0.238856f, 0.864188f, -0.442863f}, + {0.262866f, 0.951056f, -0.162460f}, + {0.500000f, 0.809017f, -0.309017f}, + {0.850651f, 0.525731f, 0.000000f}, + {0.716567f, 0.681718f, 0.147621f}, + {0.716567f, 0.681718f, -0.147621f}, + {0.525731f, 0.850651f, 0.000000f}, + {0.425325f, 0.688191f, 0.587785f}, + {0.864188f, 0.442863f, 0.238856f}, + {0.688191f, 0.587785f, 0.425325f}, + {0.809017f, 0.309017f, 0.500000f}, + {0.681718f, 0.147621f, 0.716567f}, + {0.587785f, 0.425325f, 0.688191f}, + {0.955423f, 0.295242f, 0.000000f}, + {1.000000f, 0.000000f, 0.000000f}, + {0.951056f, 0.162460f, 0.262866f}, + {0.850651f, -0.525731f, 0.000000f}, + {0.955423f, -0.295242f, 0.000000f}, + {0.864188f, -0.442863f, 0.238856f}, + {0.951056f, -0.162460f, 0.262866f}, + {0.809017f, -0.309017f, 0.500000f}, + {0.681718f, -0.147621f, 0.716567f}, + {0.850651f, 0.000000f, 0.525731f}, + {0.864188f, 0.442863f, -0.238856f}, + {0.809017f, 0.309017f, -0.500000f}, + {0.951056f, 0.162460f, -0.262866f}, + {0.525731f, 0.000000f, -0.850651f}, + {0.681718f, 0.147621f, -0.716567f}, + {0.681718f, -0.147621f, -0.716567f}, + {0.850651f, 0.000000f, -0.525731f}, + {0.809017f, -0.309017f, -0.500000f}, + {0.864188f, -0.442863f, -0.238856f}, + {0.951056f, -0.162460f, -0.262866f}, + {0.147621f, 0.716567f, -0.681718f}, + {0.309017f, 0.500000f, -0.809017f}, + {0.425325f, 0.688191f, -0.587785f}, + {0.442863f, 0.238856f, -0.864188f}, + {0.587785f, 0.425325f, -0.688191f}, + {0.688191f, 0.587785f, -0.425325f}, + {-0.147621f, 0.716567f, -0.681718f}, + {-0.309017f, 0.500000f, -0.809017f}, + {0.000000f, 0.525731f, -0.850651f}, + {-0.525731f, 0.000000f, -0.850651f}, + {-0.442863f, 0.238856f, -0.864188f}, + {-0.295242f, 0.000000f, -0.955423f}, + {-0.162460f, 0.262866f, -0.951056f}, + {0.000000f, 0.000000f, -1.000000f}, + {0.295242f, 0.000000f, -0.955423f}, + {0.162460f, 0.262866f, -0.951056f}, + {-0.442863f, -0.238856f, -0.864188f}, + {-0.309017f, -0.500000f, -0.809017f}, + {-0.162460f, -0.262866f, -0.951056f}, + {0.000000f, -0.850651f, -0.525731f}, + {-0.147621f, -0.716567f, -0.681718f}, + {0.147621f, -0.716567f, -0.681718f}, + {0.000000f, -0.525731f, -0.850651f}, + {0.309017f, -0.500000f, -0.809017f}, + {0.442863f, -0.238856f, -0.864188f}, + {0.162460f, -0.262866f, -0.951056f}, + {0.238856f, -0.864188f, -0.442863f}, + {0.500000f, -0.809017f, -0.309017f}, + {0.425325f, -0.688191f, -0.587785f}, + {0.716567f, -0.681718f, -0.147621f}, + {0.688191f, -0.587785f, -0.425325f}, + {0.587785f, -0.425325f, -0.688191f}, + {0.000000f, -0.955423f, -0.295242f}, + {0.000000f, -1.000000f, 0.000000f}, + {0.262866f, -0.951056f, -0.162460f}, + {0.000000f, -0.850651f, 0.525731f}, + {0.000000f, -0.955423f, 0.295242f}, + {0.238856f, -0.864188f, 0.442863f}, + {0.262866f, -0.951056f, 0.162460f}, + {0.500000f, -0.809017f, 0.309017f}, + {0.716567f, -0.681718f, 0.147621f}, + {0.525731f, -0.850651f, 0.000000f}, + {-0.238856f, -0.864188f, -0.442863f}, + {-0.500000f, -0.809017f, -0.309017f}, + {-0.262866f, -0.951056f, -0.162460f}, + {-0.850651f, -0.525731f, 0.000000f}, + {-0.716567f, -0.681718f, -0.147621f}, + {-0.716567f, -0.681718f, 0.147621f}, + {-0.525731f, -0.850651f, 0.000000f}, + {-0.500000f, -0.809017f, 0.309017f}, + {-0.238856f, -0.864188f, 0.442863f}, + {-0.262866f, -0.951056f, 0.162460f}, + {-0.864188f, -0.442863f, 0.238856f}, + {-0.809017f, -0.309017f, 0.500000f}, + {-0.688191f, -0.587785f, 0.425325f}, + {-0.681718f, -0.147621f, 0.716567f}, + {-0.442863f, -0.238856f, 0.864188f}, + {-0.587785f, -0.425325f, 0.688191f}, + {-0.309017f, -0.500000f, 0.809017f}, + {-0.147621f, -0.716567f, 0.681718f}, + {-0.425325f, -0.688191f, 0.587785f}, + {-0.162460f, -0.262866f, 0.951056f}, + {0.442863f, -0.238856f, 0.864188f}, + {0.162460f, -0.262866f, 0.951056f}, + {0.309017f, -0.500000f, 0.809017f}, + {0.147621f, -0.716567f, 0.681718f}, + {0.000000f, -0.525731f, 0.850651f}, + {0.425325f, -0.688191f, 0.587785f}, + {0.587785f, -0.425325f, 0.688191f}, + {0.688191f, -0.587785f, 0.425325f}, + {-0.955423f, 0.295242f, 0.000000f}, + {-0.951056f, 0.162460f, 0.262866f}, + {-1.000000f, 0.000000f, 0.000000f}, + {-0.850651f, 0.000000f, 0.525731f}, + {-0.955423f, -0.295242f, 0.000000f}, + {-0.951056f, -0.162460f, 0.262866f}, + {-0.864188f, 0.442863f, -0.238856f}, + {-0.951056f, 0.162460f, -0.262866f}, + {-0.809017f, 0.309017f, -0.500000f}, + {-0.864188f, -0.442863f, -0.238856f}, + {-0.951056f, -0.162460f, -0.262866f}, + {-0.809017f, -0.309017f, -0.500000f}, + {-0.681718f, 0.147621f, -0.716567f}, + {-0.681718f, -0.147621f, -0.716567f}, + {-0.850651f, 0.000000f, -0.525731f}, + {-0.688191f, 0.587785f, -0.425325f}, + {-0.587785f, 0.425325f, -0.688191f}, + {-0.425325f, 0.688191f, -0.587785f}, + {-0.425325f, -0.688191f, -0.587785f}, + {-0.587785f, -0.425325f, -0.688191f}, + {-0.688191f, -0.587785f, -0.425325f} + }; + + final float[][] VERTEXNORMAL_DOTS = { + {1.23f,1.30f,1.47f,1.35f,1.56f,1.71f,1.37f,1.38f,1.59f,1.60f,1.79f,1.97f,1.88f,1.92f,1.79f,1.02f,0.93f,1.07f,0.82f,0.87f,0.88f,0.94f,0.96f,1.14f,1.11f,0.82f,0.83f,0.89f,0.89f,0.86f,0.94f,0.91f,1.00f,1.21f,0.98f,1.48f,1.30f,1.57f,0.96f,1.07f,1.14f,1.60f,1.61f,1.40f,1.37f,1.72f,1.78f,1.79f,1.93f,1.99f,1.90f,1.68f,1.71f,1.86f,1.60f,1.68f,1.78f,1.86f,1.93f,1.99f,1.97f,1.44f,1.22f,1.49f,0.93f,0.99f,0.99f,1.23f,1.22f,1.44f,1.49f,0.89f,0.89f,0.97f,0.91f,0.98f,1.19f,0.82f,0.76f,0.82f,0.71f,0.72f,0.73f,0.76f,0.79f,0.86f,0.83f,0.72f,0.76f,0.76f,0.89f,0.82f,0.89f,0.82f,0.89f,0.91f,0.83f,0.96f,1.14f,0.97f,1.40f,1.19f,0.98f,0.94f,1.00f,1.07f,1.37f,1.21f,1.48f,1.30f,1.57f,1.61f,1.37f,0.86f,0.83f,0.91f,0.82f,0.82f,0.88f,0.89f,0.96f,1.14f,0.98f,0.87f,0.93f,0.94f,1.02f,1.30f,1.07f,1.35f,1.38f,1.11f,1.56f,1.92f,1.79f,1.79f,1.59f,1.60f,1.72f,1.90f,1.79f,0.80f,0.85f,0.79f,0.93f,0.80f,0.85f,0.77f,0.74f,0.72f,0.77f,0.74f,0.72f,0.70f,0.70f,0.71f,0.76f,0.73f,0.79f,0.79f,0.73f,0.76f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.26f,1.26f,1.48f,1.23f,1.50f,1.71f,1.14f,1.19f,1.38f,1.46f,1.64f,1.94f,1.87f,1.84f,1.71f,1.02f,0.92f,1.00f,0.79f,0.85f,0.84f,0.91f,0.90f,0.98f,0.99f,0.77f,0.77f,0.83f,0.82f,0.79f,0.86f,0.84f,0.92f,0.99f,0.91f,1.24f,1.03f,1.33f,0.88f,0.94f,0.97f,1.41f,1.39f,1.18f,1.11f,1.51f,1.61f,1.59f,1.80f,1.91f,1.76f,1.54f,1.65f,1.76f,1.70f,1.70f,1.85f,1.85f,1.97f,1.99f,1.93f,1.28f,1.09f,1.39f,0.92f,0.97f,0.99f,1.18f,1.26f,1.52f,1.48f,0.83f,0.85f,0.90f,0.88f,0.93f,1.00f,0.77f,0.73f,0.78f,0.72f,0.71f,0.74f,0.75f,0.79f,0.86f,0.81f,0.75f,0.81f,0.79f,0.96f,0.88f,0.94f,0.86f,0.93f,0.92f,0.85f,1.08f,1.33f,1.05f,1.55f,1.31f,1.01f,1.05f,1.27f,1.31f,1.60f,1.47f,1.70f,1.54f,1.76f,1.76f,1.57f,0.93f,0.90f,0.99f,0.88f,0.88f,0.95f,0.97f,1.11f,1.39f,1.20f,0.92f,0.97f,1.01f,1.10f,1.39f,1.22f,1.51f,1.58f,1.32f,1.64f,1.97f,1.85f,1.91f,1.77f,1.74f,1.88f,1.99f,1.91f,0.79f,0.86f,0.80f,0.94f,0.84f,0.88f,0.74f,0.74f,0.71f,0.82f,0.77f,0.76f,0.70f,0.73f,0.72f,0.73f,0.70f,0.74f,0.85f,0.77f,0.82f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.34f,1.27f,1.53f,1.17f,1.46f,1.71f,0.98f,1.05f,1.20f,1.34f,1.48f,1.86f,1.82f,1.71f,1.62f,1.09f,0.94f,0.99f,0.79f,0.85f,0.82f,0.90f,0.87f,0.93f,0.96f,0.76f,0.74f,0.79f,0.76f,0.74f,0.79f,0.78f,0.85f,0.92f,0.85f,1.00f,0.93f,1.06f,0.81f,0.86f,0.89f,1.16f,1.12f,0.97f,0.95f,1.28f,1.38f,1.35f,1.60f,1.77f,1.57f,1.33f,1.50f,1.58f,1.69f,1.63f,1.82f,1.74f,1.91f,1.92f,1.80f,1.04f,0.97f,1.21f,0.90f,0.93f,0.97f,1.05f,1.21f,1.48f,1.37f,0.77f,0.80f,0.84f,0.85f,0.88f,0.92f,0.73f,0.71f,0.74f,0.74f,0.71f,0.75f,0.73f,0.79f,0.84f,0.78f,0.79f,0.86f,0.81f,1.05f,0.94f,0.99f,0.90f,0.95f,0.92f,0.86f,1.24f,1.44f,1.14f,1.59f,1.34f,1.02f,1.27f,1.50f,1.49f,1.80f,1.69f,1.86f,1.72f,1.87f,1.80f,1.69f,1.00f,0.98f,1.23f,0.95f,0.96f,1.09f,1.16f,1.37f,1.63f,1.46f,0.99f,1.10f,1.25f,1.24f,1.51f,1.41f,1.67f,1.77f,1.55f,1.72f,1.95f,1.89f,1.98f,1.91f,1.86f,1.97f,1.99f,1.94f,0.81f,0.89f,0.85f,0.98f,0.90f,0.94f,0.75f,0.78f,0.73f,0.89f,0.83f,0.82f,0.72f,0.77f,0.76f,0.72f,0.70f,0.71f,0.91f,0.83f,0.89f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.46f,1.34f,1.60f,1.16f,1.46f,1.71f,0.94f,0.99f,1.05f,1.26f,1.33f,1.74f,1.76f,1.57f,1.54f,1.23f,0.98f,1.05f,0.83f,0.89f,0.84f,0.92f,0.87f,0.91f,0.96f,0.78f,0.74f,0.79f,0.72f,0.72f,0.75f,0.76f,0.80f,0.88f,0.83f,0.94f,0.87f,0.95f,0.76f,0.80f,0.82f,0.97f,0.96f,0.89f,0.88f,1.08f,1.11f,1.10f,1.37f,1.59f,1.37f,1.07f,1.27f,1.34f,1.57f,1.45f,1.69f,1.55f,1.77f,1.79f,1.60f,0.93f,0.90f,0.99f,0.86f,0.87f,0.93f,0.96f,1.07f,1.35f,1.18f,0.73f,0.76f,0.77f,0.81f,0.82f,0.85f,0.70f,0.71f,0.72f,0.78f,0.73f,0.77f,0.73f,0.79f,0.82f,0.76f,0.83f,0.90f,0.84f,1.18f,0.98f,1.03f,0.92f,0.95f,0.90f,0.86f,1.32f,1.45f,1.15f,1.53f,1.27f,0.99f,1.42f,1.65f,1.58f,1.93f,1.83f,1.94f,1.81f,1.88f,1.74f,1.70f,1.19f,1.17f,1.44f,1.11f,1.15f,1.36f,1.41f,1.61f,1.81f,1.67f,1.22f,1.34f,1.50f,1.42f,1.65f,1.61f,1.82f,1.91f,1.75f,1.80f,1.89f,1.89f,1.98f,1.99f,1.94f,1.98f,1.92f,1.87f,0.86f,0.95f,0.92f,1.14f,0.98f,1.03f,0.79f,0.84f,0.77f,0.97f,0.90f,0.89f,0.76f,0.82f,0.82f,0.74f,0.72f,0.71f,0.98f,0.89f,0.97f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.60f,1.44f,1.68f,1.22f,1.49f,1.71f,0.93f,0.99f,0.99f,1.23f,1.22f,1.60f,1.68f,1.44f,1.49f,1.40f,1.14f,1.19f,0.89f,0.96f,0.89f,0.97f,0.89f,0.91f,0.98f,0.82f,0.76f,0.82f,0.71f,0.72f,0.73f,0.76f,0.79f,0.86f,0.83f,0.91f,0.83f,0.89f,0.72f,0.76f,0.76f,0.89f,0.89f,0.82f,0.82f,0.98f,0.96f,0.97f,1.14f,1.40f,1.19f,0.94f,1.00f,1.07f,1.37f,1.21f,1.48f,1.30f,1.57f,1.61f,1.37f,0.86f,0.83f,0.91f,0.82f,0.82f,0.88f,0.89f,0.96f,1.14f,0.98f,0.70f,0.72f,0.73f,0.77f,0.76f,0.79f,0.70f,0.72f,0.71f,0.82f,0.77f,0.80f,0.74f,0.79f,0.80f,0.74f,0.87f,0.93f,0.85f,1.23f,1.02f,1.02f,0.93f,0.93f,0.87f,0.85f,1.30f,1.35f,1.07f,1.38f,1.11f,0.94f,1.47f,1.71f,1.56f,1.97f,1.88f,1.92f,1.79f,1.79f,1.59f,1.60f,1.30f,1.35f,1.56f,1.37f,1.38f,1.59f,1.60f,1.79f,1.92f,1.79f,1.48f,1.57f,1.72f,1.61f,1.78f,1.79f,1.93f,1.99f,1.90f,1.86f,1.78f,1.86f,1.93f,1.99f,1.97f,1.90f,1.79f,1.72f,0.94f,1.07f,1.00f,1.37f,1.21f,1.30f,0.86f,0.91f,0.83f,1.14f,0.98f,0.96f,0.82f,0.88f,0.89f,0.79f,0.76f,0.73f,1.07f,0.94f,1.11f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.74f,1.57f,1.76f,1.33f,1.54f,1.71f,0.94f,1.05f,0.99f,1.26f,1.16f,1.46f,1.60f,1.34f,1.46f,1.59f,1.37f,1.37f,0.97f,1.11f,0.96f,1.10f,0.95f,0.94f,1.08f,0.89f,0.82f,0.88f,0.72f,0.76f,0.75f,0.80f,0.80f,0.88f,0.87f,0.91f,0.83f,0.87f,0.72f,0.76f,0.74f,0.83f,0.84f,0.78f,0.79f,0.96f,0.89f,0.92f,0.98f,1.23f,1.05f,0.86f,0.92f,0.95f,1.11f,0.98f,1.22f,1.03f,1.34f,1.42f,1.14f,0.79f,0.77f,0.84f,0.78f,0.76f,0.82f,0.82f,0.89f,0.97f,0.90f,0.70f,0.71f,0.71f,0.73f,0.72f,0.74f,0.73f,0.76f,0.72f,0.86f,0.81f,0.82f,0.76f,0.79f,0.77f,0.73f,0.90f,0.95f,0.86f,1.18f,1.03f,0.98f,0.92f,0.90f,0.83f,0.84f,1.19f,1.17f,0.98f,1.15f,0.97f,0.89f,1.42f,1.65f,1.44f,1.93f,1.83f,1.81f,1.67f,1.61f,1.36f,1.41f,1.32f,1.45f,1.58f,1.57f,1.53f,1.74f,1.70f,1.88f,1.94f,1.81f,1.69f,1.77f,1.87f,1.79f,1.89f,1.92f,1.98f,1.99f,1.98f,1.89f,1.65f,1.80f,1.82f,1.91f,1.94f,1.75f,1.61f,1.50f,1.07f,1.34f,1.27f,1.60f,1.45f,1.55f,0.93f,0.99f,0.90f,1.35f,1.18f,1.07f,0.87f,0.93f,0.96f,0.85f,0.82f,0.77f,1.15f,0.99f,1.27f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.86f,1.71f,1.82f,1.48f,1.62f,1.71f,0.98f,1.20f,1.05f,1.34f,1.17f,1.34f,1.53f,1.27f,1.46f,1.77f,1.60f,1.57f,1.16f,1.38f,1.12f,1.35f,1.06f,1.00f,1.28f,0.97f,0.89f,0.95f,0.76f,0.81f,0.79f,0.86f,0.85f,0.92f,0.93f,0.93f,0.85f,0.87f,0.74f,0.78f,0.74f,0.79f,0.82f,0.76f,0.79f,0.96f,0.85f,0.90f,0.94f,1.09f,0.99f,0.81f,0.85f,0.89f,0.95f,0.90f,0.99f,0.94f,1.10f,1.24f,0.98f,0.75f,0.73f,0.78f,0.74f,0.72f,0.77f,0.76f,0.82f,0.89f,0.83f,0.73f,0.71f,0.71f,0.71f,0.70f,0.72f,0.77f,0.80f,0.74f,0.90f,0.85f,0.84f,0.78f,0.79f,0.75f,0.73f,0.92f,0.95f,0.86f,1.05f,0.99f,0.94f,0.90f,0.86f,0.79f,0.81f,1.00f,0.98f,0.91f,0.96f,0.89f,0.83f,1.27f,1.50f,1.23f,1.80f,1.69f,1.63f,1.46f,1.37f,1.09f,1.16f,1.24f,1.44f,1.49f,1.69f,1.59f,1.80f,1.69f,1.87f,1.86f,1.72f,1.82f,1.91f,1.94f,1.92f,1.95f,1.99f,1.98f,1.91f,1.97f,1.89f,1.51f,1.72f,1.67f,1.77f,1.86f,1.55f,1.41f,1.25f,1.33f,1.58f,1.50f,1.80f,1.63f,1.74f,1.04f,1.21f,0.97f,1.48f,1.37f,1.21f,0.93f,0.97f,1.05f,0.92f,0.88f,0.84f,1.14f,1.02f,1.34f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.94f,1.84f,1.87f,1.64f,1.71f,1.71f,1.14f,1.38f,1.19f,1.46f,1.23f,1.26f,1.48f,1.26f,1.50f,1.91f,1.80f,1.76f,1.41f,1.61f,1.39f,1.59f,1.33f,1.24f,1.51f,1.18f,0.97f,1.11f,0.82f,0.88f,0.86f,0.94f,0.92f,0.99f,1.03f,0.98f,0.91f,0.90f,0.79f,0.84f,0.77f,0.79f,0.84f,0.77f,0.83f,0.99f,0.85f,0.91f,0.92f,1.02f,1.00f,0.79f,0.80f,0.86f,0.88f,0.84f,0.92f,0.88f,0.97f,1.10f,0.94f,0.74f,0.71f,0.74f,0.72f,0.70f,0.73f,0.72f,0.76f,0.82f,0.77f,0.77f,0.73f,0.74f,0.71f,0.70f,0.73f,0.83f,0.85f,0.78f,0.92f,0.88f,0.86f,0.81f,0.79f,0.74f,0.75f,0.92f,0.93f,0.85f,0.96f,0.94f,0.88f,0.86f,0.81f,0.75f,0.79f,0.93f,0.90f,0.85f,0.88f,0.82f,0.77f,1.05f,1.27f,0.99f,1.60f,1.47f,1.39f,1.20f,1.11f,0.95f,0.97f,1.08f,1.33f,1.31f,1.70f,1.55f,1.76f,1.57f,1.76f,1.70f,1.54f,1.85f,1.97f,1.91f,1.99f,1.97f,1.99f,1.91f,1.77f,1.88f,1.85f,1.39f,1.64f,1.51f,1.58f,1.74f,1.32f,1.22f,1.01f,1.54f,1.76f,1.65f,1.93f,1.70f,1.85f,1.28f,1.39f,1.09f,1.52f,1.48f,1.26f,0.97f,0.99f,1.18f,1.00f,0.93f,0.90f,1.05f,1.01f,1.31f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.97f,1.92f,1.88f,1.79f,1.79f,1.71f,1.37f,1.59f,1.38f,1.60f,1.35f,1.23f,1.47f,1.30f,1.56f,1.99f,1.93f,1.90f,1.60f,1.78f,1.61f,1.79f,1.57f,1.48f,1.72f,1.40f,1.14f,1.37f,0.89f,0.96f,0.94f,1.07f,1.00f,1.21f,1.30f,1.14f,0.98f,0.96f,0.86f,0.91f,0.83f,0.82f,0.88f,0.82f,0.89f,1.11f,0.87f,0.94f,0.93f,1.02f,1.07f,0.80f,0.79f,0.85f,0.82f,0.80f,0.87f,0.85f,0.93f,1.02f,0.93f,0.77f,0.72f,0.74f,0.71f,0.70f,0.70f,0.71f,0.72f,0.77f,0.74f,0.82f,0.76f,0.79f,0.72f,0.73f,0.76f,0.89f,0.89f,0.82f,0.93f,0.91f,0.86f,0.83f,0.79f,0.73f,0.76f,0.91f,0.89f,0.83f,0.89f,0.89f,0.82f,0.82f,0.76f,0.72f,0.76f,0.86f,0.83f,0.79f,0.82f,0.76f,0.73f,0.94f,1.00f,0.91f,1.37f,1.21f,1.14f,0.98f,0.96f,0.88f,0.89f,0.96f,1.14f,1.07f,1.60f,1.40f,1.61f,1.37f,1.57f,1.48f,1.30f,1.78f,1.93f,1.79f,1.99f,1.92f,1.90f,1.79f,1.59f,1.72f,1.79f,1.30f,1.56f,1.35f,1.38f,1.60f,1.11f,1.07f,0.94f,1.68f,1.86f,1.71f,1.97f,1.68f,1.86f,1.44f,1.49f,1.22f,1.44f,1.49f,1.22f,0.99f,0.99f,1.23f,1.19f,0.98f,0.97f,0.97f,0.98f,1.19f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.94f,1.97f,1.87f,1.91f,1.85f,1.71f,1.60f,1.77f,1.58f,1.74f,1.51f,1.26f,1.48f,1.39f,1.64f,1.99f,1.97f,1.99f,1.70f,1.85f,1.76f,1.91f,1.76f,1.70f,1.88f,1.55f,1.33f,1.57f,0.96f,1.08f,1.05f,1.31f,1.27f,1.47f,1.54f,1.39f,1.20f,1.11f,0.93f,0.99f,0.90f,0.88f,0.95f,0.88f,0.97f,1.32f,0.92f,1.01f,0.97f,1.10f,1.22f,0.84f,0.80f,0.88f,0.79f,0.79f,0.85f,0.86f,0.92f,1.02f,0.94f,0.82f,0.76f,0.77f,0.72f,0.73f,0.70f,0.72f,0.71f,0.74f,0.74f,0.88f,0.81f,0.85f,0.75f,0.77f,0.82f,0.94f,0.93f,0.86f,0.92f,0.92f,0.86f,0.85f,0.79f,0.74f,0.79f,0.88f,0.85f,0.81f,0.82f,0.83f,0.77f,0.78f,0.73f,0.71f,0.75f,0.79f,0.77f,0.74f,0.77f,0.73f,0.70f,0.86f,0.92f,0.84f,1.14f,0.99f,0.98f,0.91f,0.90f,0.84f,0.83f,0.88f,0.97f,0.94f,1.41f,1.18f,1.39f,1.11f,1.33f,1.24f,1.03f,1.61f,1.80f,1.59f,1.91f,1.84f,1.76f,1.64f,1.38f,1.51f,1.71f,1.26f,1.50f,1.23f,1.19f,1.46f,0.99f,1.00f,0.91f,1.70f,1.85f,1.65f,1.93f,1.54f,1.76f,1.52f,1.48f,1.26f,1.28f,1.39f,1.09f,0.99f,0.97f,1.18f,1.31f,1.01f,1.05f,0.90f,0.93f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.86f,1.95f,1.82f,1.98f,1.89f,1.71f,1.80f,1.91f,1.77f,1.86f,1.67f,1.34f,1.53f,1.51f,1.72f,1.92f,1.91f,1.99f,1.69f,1.82f,1.80f,1.94f,1.87f,1.86f,1.97f,1.59f,1.44f,1.69f,1.05f,1.24f,1.27f,1.49f,1.50f,1.69f,1.72f,1.63f,1.46f,1.37f,1.00f,1.23f,0.98f,0.95f,1.09f,0.96f,1.16f,1.55f,0.99f,1.25f,1.10f,1.24f,1.41f,0.90f,0.85f,0.94f,0.79f,0.81f,0.85f,0.89f,0.94f,1.09f,0.98f,0.89f,0.82f,0.83f,0.74f,0.77f,0.72f,0.76f,0.73f,0.75f,0.78f,0.94f,0.86f,0.91f,0.79f,0.83f,0.89f,0.99f,0.95f,0.90f,0.90f,0.92f,0.84f,0.86f,0.79f,0.75f,0.81f,0.85f,0.80f,0.78f,0.76f,0.77f,0.73f,0.74f,0.71f,0.71f,0.73f,0.74f,0.74f,0.71f,0.76f,0.72f,0.70f,0.79f,0.85f,0.78f,0.98f,0.92f,0.93f,0.85f,0.87f,0.82f,0.79f,0.81f,0.89f,0.86f,1.16f,0.97f,1.12f,0.95f,1.06f,1.00f,0.93f,1.38f,1.60f,1.35f,1.77f,1.71f,1.57f,1.48f,1.20f,1.28f,1.62f,1.27f,1.46f,1.17f,1.05f,1.34f,0.96f,0.99f,0.90f,1.63f,1.74f,1.50f,1.80f,1.33f,1.58f,1.48f,1.37f,1.21f,1.04f,1.21f,0.97f,0.97f,0.93f,1.05f,1.34f,1.02f,1.14f,0.84f,0.88f,0.92f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.74f,1.89f,1.76f,1.98f,1.89f,1.71f,1.93f,1.99f,1.91f,1.94f,1.82f,1.46f,1.60f,1.65f,1.80f,1.79f,1.77f,1.92f,1.57f,1.69f,1.74f,1.87f,1.88f,1.94f,1.98f,1.53f,1.45f,1.70f,1.18f,1.32f,1.42f,1.58f,1.65f,1.83f,1.81f,1.81f,1.67f,1.61f,1.19f,1.44f,1.17f,1.11f,1.36f,1.15f,1.41f,1.75f,1.22f,1.50f,1.34f,1.42f,1.61f,0.98f,0.92f,1.03f,0.83f,0.86f,0.89f,0.95f,0.98f,1.23f,1.14f,0.97f,0.89f,0.90f,0.78f,0.82f,0.76f,0.82f,0.77f,0.79f,0.84f,0.98f,0.90f,0.98f,0.83f,0.89f,0.97f,1.03f,0.95f,0.92f,0.86f,0.90f,0.82f,0.86f,0.79f,0.77f,0.84f,0.81f,0.76f,0.76f,0.72f,0.73f,0.70f,0.72f,0.71f,0.73f,0.73f,0.72f,0.74f,0.71f,0.78f,0.74f,0.72f,0.75f,0.80f,0.76f,0.94f,0.88f,0.91f,0.83f,0.87f,0.84f,0.79f,0.76f,0.82f,0.80f,0.97f,0.89f,0.96f,0.88f,0.95f,0.94f,0.87f,1.11f,1.37f,1.10f,1.59f,1.57f,1.37f,1.33f,1.05f,1.08f,1.54f,1.34f,1.46f,1.16f,0.99f,1.26f,0.96f,1.05f,0.92f,1.45f,1.55f,1.27f,1.60f,1.07f,1.34f,1.35f,1.18f,1.07f,0.93f,0.99f,0.90f,0.93f,0.87f,0.96f,1.27f,0.99f,1.15f,0.77f,0.82f,0.85f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.60f,1.78f,1.68f,1.93f,1.86f,1.71f,1.97f,1.99f,1.99f,1.97f,1.93f,1.60f,1.68f,1.78f,1.86f,1.61f,1.57f,1.79f,1.37f,1.48f,1.59f,1.72f,1.79f,1.92f,1.90f,1.38f,1.35f,1.60f,1.23f,1.30f,1.47f,1.56f,1.71f,1.88f,1.79f,1.92f,1.79f,1.79f,1.30f,1.56f,1.35f,1.37f,1.59f,1.38f,1.60f,1.90f,1.48f,1.72f,1.57f,1.61f,1.79f,1.21f,1.00f,1.30f,0.89f,0.94f,0.96f,1.07f,1.14f,1.40f,1.37f,1.14f,0.96f,0.98f,0.82f,0.88f,0.82f,0.89f,0.83f,0.86f,0.91f,1.02f,0.93f,1.07f,0.87f,0.94f,1.11f,1.02f,0.93f,0.93f,0.82f,0.87f,0.80f,0.85f,0.79f,0.80f,0.85f,0.77f,0.72f,0.74f,0.71f,0.70f,0.70f,0.71f,0.72f,0.77f,0.74f,0.72f,0.76f,0.73f,0.82f,0.79f,0.76f,0.73f,0.79f,0.76f,0.93f,0.86f,0.91f,0.83f,0.89f,0.89f,0.82f,0.72f,0.76f,0.76f,0.89f,0.82f,0.89f,0.82f,0.89f,0.91f,0.83f,0.96f,1.14f,0.97f,1.40f,1.44f,1.19f,1.22f,0.99f,0.98f,1.49f,1.44f,1.49f,1.22f,0.99f,1.23f,0.98f,1.19f,0.97f,1.21f,1.30f,1.00f,1.37f,0.94f,1.07f,1.14f,0.98f,0.96f,0.86f,0.91f,0.83f,0.88f,0.82f,0.89f,1.11f,0.94f,1.07f,0.73f,0.76f,0.79f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.46f,1.65f,1.60f,1.82f,1.80f,1.71f,1.93f,1.91f,1.99f,1.94f,1.98f,1.74f,1.76f,1.89f,1.89f,1.42f,1.34f,1.61f,1.11f,1.22f,1.36f,1.50f,1.61f,1.81f,1.75f,1.15f,1.17f,1.41f,1.18f,1.19f,1.42f,1.44f,1.65f,1.83f,1.67f,1.94f,1.81f,1.88f,1.32f,1.58f,1.45f,1.57f,1.74f,1.53f,1.70f,1.98f,1.69f,1.87f,1.77f,1.79f,1.92f,1.45f,1.27f,1.55f,0.97f,1.07f,1.11f,1.34f,1.37f,1.59f,1.60f,1.35f,1.07f,1.18f,0.86f,0.93f,0.87f,0.96f,0.90f,0.93f,0.99f,1.03f,0.95f,1.15f,0.90f,0.99f,1.27f,0.98f,0.90f,0.92f,0.78f,0.83f,0.77f,0.84f,0.79f,0.82f,0.86f,0.73f,0.71f,0.73f,0.72f,0.70f,0.73f,0.72f,0.76f,0.81f,0.76f,0.76f,0.82f,0.77f,0.89f,0.85f,0.82f,0.75f,0.80f,0.80f,0.94f,0.88f,0.94f,0.87f,0.95f,0.96f,0.88f,0.72f,0.74f,0.76f,0.83f,0.78f,0.84f,0.79f,0.87f,0.91f,0.83f,0.89f,0.98f,0.92f,1.23f,1.34f,1.05f,1.16f,0.99f,0.96f,1.46f,1.57f,1.54f,1.33f,1.05f,1.26f,1.08f,1.37f,1.10f,0.98f,1.03f,0.92f,1.14f,0.86f,0.95f,0.97f,0.90f,0.89f,0.79f,0.84f,0.77f,0.82f,0.76f,0.82f,0.97f,0.89f,0.98f,0.71f,0.72f,0.74f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.34f,1.51f,1.53f,1.67f,1.72f,1.71f,1.80f,1.77f,1.91f,1.86f,1.98f,1.86f,1.82f,1.95f,1.89f,1.24f,1.10f,1.41f,0.95f,0.99f,1.09f,1.25f,1.37f,1.63f,1.55f,0.96f,0.98f,1.16f,1.05f,1.00f,1.27f,1.23f,1.50f,1.69f,1.46f,1.86f,1.72f,1.87f,1.24f,1.49f,1.44f,1.69f,1.80f,1.59f,1.69f,1.97f,1.82f,1.94f,1.91f,1.92f,1.99f,1.63f,1.50f,1.74f,1.16f,1.33f,1.38f,1.58f,1.60f,1.77f,1.80f,1.48f,1.21f,1.37f,0.90f,0.97f,0.93f,1.05f,0.97f,1.04f,1.21f,0.99f,0.95f,1.14f,0.92f,1.02f,1.34f,0.94f,0.86f,0.90f,0.74f,0.79f,0.75f,0.81f,0.79f,0.84f,0.86f,0.71f,0.71f,0.73f,0.76f,0.73f,0.77f,0.74f,0.80f,0.85f,0.78f,0.81f,0.89f,0.84f,0.97f,0.92f,0.88f,0.79f,0.85f,0.86f,0.98f,0.92f,1.00f,0.93f,1.06f,1.12f,0.95f,0.74f,0.74f,0.78f,0.79f,0.76f,0.82f,0.79f,0.87f,0.93f,0.85f,0.85f,0.94f,0.90f,1.09f,1.27f,0.99f,1.17f,1.05f,0.96f,1.46f,1.71f,1.62f,1.48f,1.20f,1.34f,1.28f,1.57f,1.35f,0.90f,0.94f,0.85f,0.98f,0.81f,0.89f,0.89f,0.83f,0.82f,0.75f,0.78f,0.73f,0.77f,0.72f,0.76f,0.89f,0.83f,0.91f,0.71f,0.70f,0.72f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f}, + {1.26f,1.39f,1.48f,1.51f,1.64f,1.71f,1.60f,1.58f,1.77f,1.74f,1.91f,1.94f,1.87f,1.97f,1.85f,1.10f,0.97f,1.22f,0.88f,0.92f,0.95f,1.01f,1.11f,1.39f,1.32f,0.88f,0.90f,0.97f,0.96f,0.93f,1.05f,0.99f,1.27f,1.47f,1.20f,1.70f,1.54f,1.76f,1.08f,1.31f,1.33f,1.70f,1.76f,1.55f,1.57f,1.88f,1.85f,1.91f,1.97f,1.99f,1.99f,1.70f,1.65f,1.85f,1.41f,1.54f,1.61f,1.76f,1.80f,1.91f,1.93f,1.52f,1.26f,1.48f,0.92f,0.99f,0.97f,1.18f,1.09f,1.28f,1.39f,0.94f,0.93f,1.05f,0.92f,1.01f,1.31f,0.88f,0.81f,0.86f,0.72f,0.75f,0.74f,0.79f,0.79f,0.86f,0.85f,0.71f,0.73f,0.75f,0.82f,0.77f,0.83f,0.78f,0.85f,0.88f,0.81f,0.88f,0.97f,0.90f,1.18f,1.00f,0.93f,0.86f,0.92f,0.94f,1.14f,0.99f,1.24f,1.03f,1.33f,1.39f,1.11f,0.79f,0.77f,0.84f,0.79f,0.77f,0.84f,0.83f,0.90f,0.98f,0.91f,0.85f,0.92f,0.91f,1.02f,1.26f,1.00f,1.23f,1.19f,0.99f,1.50f,1.84f,1.71f,1.64f,1.38f,1.46f,1.51f,1.76f,1.59f,0.84f,0.88f,0.80f,0.94f,0.79f,0.86f,0.82f,0.77f,0.76f,0.74f,0.74f,0.71f,0.73f,0.70f,0.72f,0.82f,0.77f,0.85f,0.74f,0.70f,0.73f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f,1.00f} + }; + +} diff --git a/src/jake2/render/fast/Draw.java b/src/jake2/render/fast/Draw.java new file mode 100644 index 0000000..b13891d --- /dev/null +++ b/src/jake2/render/fast/Draw.java @@ -0,0 +1,412 @@ +/* + * Draw.java + * Copyright (C) 2003 + * + * $Id: Draw.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.client.VID; +import jake2.qcommon.Com; +import jake2.render.image_t; +import jake2.util.Lib; + +import java.awt.Dimension; +import java.nio.ByteBuffer; +import java.nio.IntBuffer; + +/** + * Draw + * (gl_draw.c) + * + * @author cwei + */ +public abstract class Draw extends Image { + + /* + =============== + Draw_InitLocal + =============== + */ + void Draw_InitLocal() { + // load console characters (don't bilerp characters) + draw_chars = GL_FindImage("pics/conchars.pcx", it_pic); + GL_Bind(draw_chars.texnum); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + /* + ================ + Draw_Char + + Draws one 8*8 graphics character with 0 being transparent. + It can be clipped to the top of the screen to allow the console to be + smoothly scrolled off. + ================ + */ + public void Draw_Char(int x, int y, int num) { + + num &= 255; + + if ( (num&127) == 32 ) return; // space + + if (y <= -8) return; // totally off screen + + int row = num>>4; + int col = num&15; + + float frow = row*0.0625f; + float fcol = col*0.0625f; + float size = 0.0625f; + + GL_Bind(draw_chars.texnum); + + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (fcol, frow); + gl.glVertex2f (x, y); + gl.glTexCoord2f (fcol + size, frow); + gl.glVertex2f (x+8, y); + gl.glTexCoord2f (fcol + size, frow + size); + gl.glVertex2f (x+8, y+8); + gl.glTexCoord2f (fcol, frow + size); + gl.glVertex2f (x, y+8); + gl.glEnd (); + } + + + /* + ============= + Draw_FindPic + ============= + */ + public image_t Draw_FindPic(String name) { + image_t image = null; + String fullname; + + if (!name.startsWith("/") && !name.startsWith("\\")) + { + fullname = "pics/" + name + ".pcx"; + image = GL_FindImage(fullname, it_pic); + } else { + image = GL_FindImage(name.substring(1), it_pic); + } + return image; + } + + + /* + ============= + Draw_GetPicSize + ============= + */ + public void Draw_GetPicSize(Dimension dim, String pic) { + + image_t image = Draw_FindPic(pic); + dim.width = (image != null) ? image.width : -1; + dim.height = (image != null) ? image.height : -1; + } + + /* + ============= + Draw_StretchPic + ============= + */ + public void Draw_StretchPic (int x, int y, int w, int h, String pic) { + + image_t image; + + image = Draw_FindPic(pic); + if (image == null) + { + VID.Printf (Defines.PRINT_ALL, "Can't find pic: " + pic +'\n'); + return; + } + + if (scrap_dirty) + Scrap_Upload(); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0) ) && !image.has_alpha) + gl.glDisable(GL_ALPHA_TEST); + + GL_Bind(image.texnum); + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (image.sl, image.tl); + gl.glVertex2f (x, y); + gl.glTexCoord2f (image.sh, image.tl); + gl.glVertex2f (x+w, y); + gl.glTexCoord2f (image.sh, image.th); + gl.glVertex2f (x+w, y+h); + gl.glTexCoord2f (image.sl, image.th); + gl.glVertex2f (x, y+h); + gl.glEnd (); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) !=0 ) ) && !image.has_alpha) + gl.glEnable(GL_ALPHA_TEST); + } + + + /* + ============= + Draw_Pic + ============= + */ + public void Draw_Pic(int x, int y, String pic) + { + image_t image; + + image = Draw_FindPic(pic); + if (image == null) + { + VID.Printf(Defines.PRINT_ALL, "Can't find pic: " +pic + '\n'); + return; + } + if (scrap_dirty) + Scrap_Upload(); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glDisable (GL_ALPHA_TEST); + + GL_Bind(image.texnum); + + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (image.sl, image.tl); + gl.glVertex2f (x, y); + gl.glTexCoord2f (image.sh, image.tl); + gl.glVertex2f (x+image.width, y); + gl.glTexCoord2f (image.sh, image.th); + gl.glVertex2f (x+image.width, y+image.height); + gl.glTexCoord2f (image.sl, image.th); + gl.glVertex2f (x, y+image.height); + gl.glEnd (); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glEnable (GL_ALPHA_TEST); + } + + /* + ============= + Draw_TileClear + + This repeats a 64*64 tile graphic to fill the screen around a sized down + refresh window. + ============= + */ + public void Draw_TileClear(int x, int y, int w, int h, String pic) { + image_t image; + + image = Draw_FindPic(pic); + if (image == null) + { + VID.Printf(Defines.PRINT_ALL, "Can't find pic: " + pic + '\n'); + return; + } + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glDisable(GL_ALPHA_TEST); + + GL_Bind(image.texnum); + gl.glBegin (GL_QUADS); + gl.glTexCoord2f(x/64.0f, y/64.0f); + gl.glVertex2f (x, y); + gl.glTexCoord2f( (x+w)/64.0f, y/64.0f); + gl.glVertex2f(x+w, y); + gl.glTexCoord2f( (x+w)/64.0f, (y+h)/64.0f); + gl.glVertex2f(x+w, y+h); + gl.glTexCoord2f( x/64.0f, (y+h)/64.0f ); + gl.glVertex2f (x, y+h); + gl.glEnd (); + + if ( ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) && !image.has_alpha) + gl.glEnable(GL_ALPHA_TEST); + } + + + /* + ============= + Draw_Fill + + Fills a box of pixels with a single color + ============= + */ + public 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"); + + gl.glDisable(GL_TEXTURE_2D); + + int color = d_8to24table[colorIndex]; + + gl.glColor3ub( + (byte)((color >> 0) & 0xff), // r + (byte)((color >> 8) & 0xff), // g + (byte)((color >> 16) & 0xff) // b + ); + + gl.glBegin (GL_QUADS); + + gl.glVertex2f(x,y); + gl.glVertex2f(x+w, y); + gl.glVertex2f(x+w, y+h); + gl.glVertex2f(x, y+h); + + gl.glEnd(); + gl.glColor3f(1,1,1); + gl.glEnable(GL_TEXTURE_2D); + } + + //============================================================================= + + /* + ================ + Draw_FadeScreen + ================ + */ + public void Draw_FadeScreen() { + gl.glEnable(GL_BLEND); + gl.glDisable(GL_TEXTURE_2D); + gl.glColor4f(0, 0, 0, 0.8f); + gl.glBegin(GL_QUADS); + + gl.glVertex2f(0,0); + gl.glVertex2f(vid.width, 0); + gl.glVertex2f(vid.width, vid.height); + gl.glVertex2f(0, vid.height); + + gl.glEnd(); + gl.glColor4f(1,1,1,1); + gl.glEnable(GL_TEXTURE_2D); + gl.glDisable(GL_BLEND); + } + +// ==================================================================== + + IntBuffer image32=Lib.newIntBuffer(256*256); + ByteBuffer image8=Lib.newByteBuffer(256*256); + + + /* + ============= + Draw_StretchRaw + ============= + */ + public 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; + 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; + } + } + gl.glTexImage2D (GL_TEXTURE_2D, 0, gl_tex_solid_format, 256, 256, 0, GL_RGBA, 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; + } + } + + gl.glTexImage2D( GL_TEXTURE_2D, + 0, + GL_COLOR_INDEX8_EXT, + 256, 256, + 0, + GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, + image8 ); + } + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + if ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) + gl.glDisable (GL_ALPHA_TEST); + + gl.glBegin (GL_QUADS); + gl.glTexCoord2f (0, 0); + gl.glVertex2f (x, y); + gl.glTexCoord2f (1, 0); + gl.glVertex2f (x+w, y); + gl.glTexCoord2f (1, t); + gl.glVertex2f (x+w, y+h); + gl.glTexCoord2f (0, t); + gl.glVertex2f (x, y+h); + gl.glEnd (); + + if ( ( gl_config.renderer == GL_RENDERER_MCD ) || ( (gl_config.renderer & GL_RENDERER_RENDITION) != 0 ) ) + gl.glEnable (GL_ALPHA_TEST); + } + +} diff --git a/src/jake2/render/fast/Image.java b/src/jake2/render/fast/Image.java new file mode 100644 index 0000000..a724cb7 --- /dev/null +++ b/src/jake2/render/fast/Image.java @@ -0,0 +1,1677 @@ +/* + * Image.java + * Copyright (C) 2003 + * + * $Id: Image.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.client.VID; +import jake2.client.particle_t; +import jake2.game.cvar_t; +import jake2.qcommon.*; +import jake2.render.image_t; +import jake2.util.Lib; +import jake2.util.Vargs; + +import java.awt.Dimension; +import java.awt.geom.AffineTransform; +import java.awt.image.AffineTransformOp; +import java.awt.image.BufferedImage; +import java.nio.*; +import java.util.*; + +/** + * Image + * + * @author cwei + */ +public abstract class Image extends Main { + + image_t draw_chars; + + image_t[] gltextures = new image_t[MAX_GLTEXTURES]; + //Map gltextures = new Hashtable(MAX_GLTEXTURES); // image_t + int numgltextures; + int base_textureid; // gltextures[i] = base_textureid+i + + byte[] intensitytable = new byte[256]; + byte[] gammatable = new byte[256]; + + cvar_t intensity; + + // + // qboolean GL_Upload8 (byte *data, int width, int height, qboolean mipmap, qboolean is_sky ); + // qboolean GL_Upload32 (unsigned *data, int width, int height, qboolean mipmap); + // + + int gl_solid_format = 3; + int gl_alpha_format = 4; + + int gl_tex_solid_format = 3; + int gl_tex_alpha_format = 4; + + int gl_filter_min = GL_LINEAR_MIPMAP_NEAREST; + int gl_filter_max = GL_LINEAR; + + Image() { + // init the texture cache + for (int i = 0; i < gltextures.length; i++) + { + gltextures[i] = new image_t(i); + } + numgltextures = 0; + } + + void GL_SetTexturePalette(int[] palette) { + + assert(palette != null && palette.length == 256) : "int palette[256] bug"; + + int i; + //byte[] temptable = new byte[768]; + + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f) + { + ByteBuffer temptable = Lib.newByteBuffer(768); + for (i = 0; i < 256; i++) { + temptable.put(i * 3 + 0, (byte) ((palette[i] >> 0) & 0xff)); + temptable.put(i * 3 + 1, (byte) ((palette[i] >> 8) & 0xff)); + temptable.put(i * 3 + 2, (byte) ((palette[i] >> 16) & 0xff)); + } + + gl.glColorTable(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, temptable); + } + } + + void GL_EnableMultitexture(boolean enable) { + if (enable) { + GL_SelectTexture(TEXTURE1); + gl.glEnable(GL_TEXTURE_2D); + GL_TexEnv(GL_REPLACE); + } + else { + GL_SelectTexture(TEXTURE1); + gl.glDisable(GL_TEXTURE_2D); + GL_TexEnv(GL_REPLACE); + } + GL_SelectTexture(TEXTURE0); + GL_TexEnv(GL_REPLACE); + } + + void GL_SelectTexture(int texture /* GLenum */) { + int tmu; + + tmu = (texture == TEXTURE0) ? 0 : 1; + + if (tmu == gl_state.currenttmu) { + return; + } + + gl_state.currenttmu = tmu; + + gl.glActiveTextureARB(texture); + gl.glClientActiveTextureARB(texture); + } + + int[] lastmodes = { -1, -1 }; + + void GL_TexEnv(int mode /* GLenum */ + ) { + + if (mode != lastmodes[gl_state.currenttmu]) { + gl.glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, mode); + lastmodes[gl_state.currenttmu] = mode; + } + } + + void GL_Bind(int texnum) { + + if ((gl_nobind.value != 0) && (draw_chars != null)) { + // performance evaluation option + texnum = draw_chars.texnum; + } + if (gl_state.currenttextures[gl_state.currenttmu] == texnum) + return; + + gl_state.currenttextures[gl_state.currenttmu] = texnum; + gl.glBindTexture(GL_TEXTURE_2D, texnum); + } + + void GL_MBind(int target /* GLenum */, int texnum) { + GL_SelectTexture(target); + if (target == TEXTURE0) { + if (gl_state.currenttextures[0] == texnum) + return; + } + else { + if (gl_state.currenttextures[1] == texnum) + return; + } + GL_Bind(texnum); + } + + // glmode_t + static class glmode_t { + String name; + int minimize, maximize; + + glmode_t(String name, int minimize, int maximze) { + this.name = name; + this.minimize = minimize; + this.maximize = maximze; + } + } + + static final glmode_t modes[] = + { + new glmode_t("GL_NEAREST", GL_NEAREST, GL_NEAREST), + new glmode_t("GL_LINEAR", GL_LINEAR, GL_LINEAR), + new glmode_t("GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST), + new glmode_t("GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR), + new glmode_t("GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST), + new glmode_t("GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR)}; + + static final int NUM_GL_MODES = modes.length; + + // gltmode_t + static class gltmode_t { + String name; + int mode; + + gltmode_t(String name, int mode) { + this.name = name; + this.mode = mode; + } + } + + static final gltmode_t[] gl_alpha_modes = + { + new gltmode_t("default", 4), + new gltmode_t("GL_RGBA", GL_RGBA), + new gltmode_t("GL_RGBA8", GL_RGBA8), + new gltmode_t("GL_RGB5_A1", GL_RGB5_A1), + new gltmode_t("GL_RGBA4", GL_RGBA4), + new gltmode_t("GL_RGBA2", GL_RGBA2), + }; + + static final int NUM_GL_ALPHA_MODES = gl_alpha_modes.length; + + static final gltmode_t[] gl_solid_modes = + { + new gltmode_t("default", 3), + new gltmode_t("GL_RGB", GL_RGB), + new gltmode_t("GL_RGB8", GL_RGB8), + new gltmode_t("GL_RGB5", GL_RGB5), + new gltmode_t("GL_RGB4", GL_RGB4), + new gltmode_t("GL_R3_G3_B2", GL_R3_G3_B2), + }; + + static final int NUM_GL_SOLID_MODES = gl_solid_modes.length; + + /* + =============== + GL_TextureMode + =============== + */ + void GL_TextureMode(String string) { + + int i; + for (i = 0; i < NUM_GL_MODES; i++) { + if (modes[i].name.equalsIgnoreCase(string)) + break; + } + + if (i == NUM_GL_MODES) { + VID.Printf(Defines.PRINT_ALL, "bad filter name: [" + string + "]\n"); + return; + } + + gl_filter_min = modes[i].minimize; + gl_filter_max = modes[i].maximize; + + image_t glt; + // change all the existing mipmap texture objects + for (i = 0; i < numgltextures; i++) { + glt = gltextures[i]; + + if (glt.type != it_pic && glt.type != it_sky) { + GL_Bind(glt.texnum); + gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); + gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + } + } + } + + /* + =============== + GL_TextureAlphaMode + =============== + */ + void GL_TextureAlphaMode(String string) { + + int i; + for (i = 0; i < NUM_GL_ALPHA_MODES; i++) { + if (gl_alpha_modes[i].name.equalsIgnoreCase(string)) + break; + } + + if (i == NUM_GL_ALPHA_MODES) { + VID.Printf(Defines.PRINT_ALL, "bad alpha texture mode name: [" + string + "]\n"); + return; + } + + gl_tex_alpha_format = gl_alpha_modes[i].mode; + } + + /* + =============== + GL_TextureSolidMode + =============== + */ + void GL_TextureSolidMode(String string) { + int i; + for (i = 0; i < NUM_GL_SOLID_MODES; i++) { + if (gl_solid_modes[i].name.equalsIgnoreCase(string)) + break; + } + + if (i == NUM_GL_SOLID_MODES) { + VID.Printf(Defines.PRINT_ALL, "bad solid texture mode name: [" + string + "]\n"); + return; + } + + gl_tex_solid_format = gl_solid_modes[i].mode; + } + + /* + =============== + GL_ImageList_f + =============== + */ + void GL_ImageList_f() { + + image_t image; + int texels; + final String[] palstrings = { "RGB", "PAL" }; + + VID.Printf(Defines.PRINT_ALL, "------------------\n"); + texels = 0; + + for (int i = 0; i < numgltextures; i++) { + image = gltextures[i]; + if (image.texnum <= 0) + continue; + + texels += image.upload_width * image.upload_height; + switch (image.type) { + case it_skin : + VID.Printf(Defines.PRINT_ALL, "M"); + break; + case it_sprite : + VID.Printf(Defines.PRINT_ALL, "S"); + break; + case it_wall : + VID.Printf(Defines.PRINT_ALL, "W"); + break; + case it_pic : + VID.Printf(Defines.PRINT_ALL, "P"); + break; + default : + VID.Printf(Defines.PRINT_ALL, " "); + break; + } + + VID.Printf( + Defines.PRINT_ALL, + " %3i %3i %s: %s\n", + new Vargs(4).add(image.upload_width).add(image.upload_height).add(palstrings[(image.paletted) ? 1 : 0]).add( + image.name)); + } + VID.Printf(Defines.PRINT_ALL, "Total texel count (not counting mipmaps): " + texels + '\n'); + } + + /* + ============================================================================= + + scrap allocation + + Allocate all the little status bar objects into a single texture + to crutch up inefficient hardware / drivers + + ============================================================================= + */ + + static final int MAX_SCRAPS = 1; + static final int BLOCK_WIDTH = 256; + static final int BLOCK_HEIGHT = 256; + + int[][] scrap_allocated = new int[MAX_SCRAPS][BLOCK_WIDTH]; + byte[][] scrap_texels = new byte[MAX_SCRAPS][BLOCK_WIDTH * BLOCK_HEIGHT]; + boolean scrap_dirty; + + static class pos_t { + int x, y; + + pos_t(int x, int y) { + this.x = x; + this.y = y; + } + } + + // returns a texture number and the position inside it + int Scrap_AllocBlock(int w, int h, pos_t pos) { + int i, j; + int best, best2; + int texnum; + + for (texnum = 0; texnum < MAX_SCRAPS; texnum++) { + best = BLOCK_HEIGHT; + + for (i = 0; i < BLOCK_WIDTH - w; i++) { + best2 = 0; + + for (j = 0; j < w; j++) { + if (scrap_allocated[texnum][i + j] >= best) + break; + if (scrap_allocated[texnum][i + j] > best2) + best2 = scrap_allocated[texnum][i + j]; + } + if (j == w) { // this is a valid spot + pos.x = i; + pos.y = best = best2; + } + } + + if (best + h > BLOCK_HEIGHT) + continue; + + for (i = 0; i < w; i++) + scrap_allocated[texnum][pos.x + i] = best + h; + + return texnum; + } + + return -1; + // Sys_Error ("Scrap_AllocBlock: full"); + } + + int scrap_uploads = 0; + + void Scrap_Upload() { + scrap_uploads++; + GL_Bind(TEXNUM_SCRAPS); + GL_Upload8(scrap_texels[0], BLOCK_WIDTH, BLOCK_HEIGHT, false, false); + scrap_dirty = false; + } + + /* + ================================================================= + + PCX LOADING + + ================================================================= + */ + + /* + ============== + LoadPCX + ============== + */ + byte[] LoadPCX(String filename, byte[][] palette, Dimension dim) { + qfiles.pcx_t pcx; + + // + // load the file + // + byte[] raw = FS.LoadFile(filename); + + if (raw == null) { + VID.Printf(Defines.PRINT_DEVELOPER, "Bad pcx file " + filename + '\n'); + return null; + } + + // + // parse the PCX file + // + pcx = new qfiles.pcx_t(raw); + + if (pcx.manufacturer != 0x0a + || pcx.version != 5 + || pcx.encoding != 1 + || pcx.bits_per_pixel != 8 + || pcx.xmax >= 640 + || pcx.ymax >= 480) { + + VID.Printf(Defines.PRINT_ALL, "Bad pcx file " + filename + '\n'); + return null; + } + + int width = pcx.xmax - pcx.xmin + 1; + int height = pcx.ymax - pcx.ymin + 1; + + byte[] pix = new byte[width * height]; + + if (palette != null) { + palette[0] = new byte[768]; + System.arraycopy(raw, raw.length - 768, palette[0], 0, 768); + } + + if (dim != null) { + dim.width = width; + dim.height = height; + } + + // + // decode pcx + // + int count = 0; + byte dataByte = 0; + int runLength = 0; + int x, y; + + for (y = 0; y < height; y++) { + for (x = 0; x < width;) { + + dataByte = pcx.data.get(); + + if ((dataByte & 0xC0) == 0xC0) { + runLength = dataByte & 0x3F; + dataByte = pcx.data.get(); + // write runLength pixel + while (runLength-- > 0) { + pix[count++] = dataByte; + x++; + } + } + else { + // write one pixel + pix[count++] = dataByte; + x++; + } + } + } + return pix; + } + + private Throwable gotoBreakOut = new Throwable(); + private Throwable gotoDone = gotoBreakOut; + + // /* + // ========================================================= + // + // TARGA LOADING + // + // ========================================================= + // */ + /* + ============= + LoadTGA + ============= + */ + byte[] LoadTGA(String name, Dimension dim) { + int columns, rows, numPixels; + int pixbuf; // index into pic + int row, column; + byte[] raw; + ByteBuffer buf_p; + int length; + qfiles.tga_t targa_header; + byte[] pic = null; + + // + // load the file + // + raw = FS.LoadFile(name); + + if (raw == null) + { + VID.Printf(Defines.PRINT_DEVELOPER, "Bad tga file "+ name +'\n'); + return null; + } + + targa_header = new qfiles.tga_t(raw); + + if (targa_header.image_type != 2 && targa_header.image_type != 10) + Com.Error(Defines.ERR_DROP, "LoadTGA: Only type 2 and 10 targa RGB images supported\n"); + + if (targa_header.colormap_type != 0 || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24)) + Com.Error (Defines.ERR_DROP, "LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n"); + + columns = targa_header.width; + rows = targa_header.height; + numPixels = columns * rows; + + if (dim != null) { + dim.width = columns; + dim.height = rows; + } + + pic = new byte[numPixels * 4]; // targa_rgba; + + if (targa_header.id_length != 0) + targa_header.data.position(targa_header.id_length); // skip TARGA image comment + + buf_p = targa_header.data; + + byte red,green,blue,alphabyte; + red = green = blue = alphabyte = 0; + int packetHeader, packetSize, j; + + if (targa_header.image_type==2) { // Uncompressed, RGB images + for(row=rows-1; row>=0; row--) { + + pixbuf = row * columns * 4; + + for(column=0; column<columns; column++) { + switch (targa_header.pixel_size) { + case 24: + + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = (byte)255; + break; + case 32: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = alphabyte; + break; + } + } + } + } + else if (targa_header.image_type==10) { // Runlength encoded RGB images + for(row=rows-1; row>=0; row--) { + + pixbuf = row * columns * 4; + try { + + for(column=0; column<columns; ) { + + packetHeader= buf_p.get() & 0xFF; + packetSize = 1 + (packetHeader & 0x7f); + + if ((packetHeader & 0x80) != 0) { // run-length packet + switch (targa_header.pixel_size) { + case 24: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = (byte)255; + break; + case 32: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = buf_p.get(); + break; + } + + for(j=0;j<packetSize;j++) { + pic[pixbuf++]=red; + pic[pixbuf++]=green; + pic[pixbuf++]=blue; + pic[pixbuf++]=alphabyte; + column++; + if (column==columns) { // run spans across rows + column=0; + if (row>0) + row--; + else + // goto label breakOut; + throw gotoBreakOut; + + pixbuf = row * columns * 4; + } + } + } + else { // non run-length packet + for(j=0;j<packetSize;j++) { + switch (targa_header.pixel_size) { + case 24: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = (byte)255; + break; + case 32: + blue = buf_p.get(); + green = buf_p.get(); + red = buf_p.get(); + alphabyte = buf_p.get(); + pic[pixbuf++] = red; + pic[pixbuf++] = green; + pic[pixbuf++] = blue; + pic[pixbuf++] = alphabyte; + break; + } + column++; + if (column==columns) { // pixel packet run spans across rows + column=0; + if (row>0) + row--; + else + // goto label breakOut; + throw gotoBreakOut; + + pixbuf = row * columns * 4; + } + } + } + } + } catch (Throwable e){ + // label breakOut: + } + } + } + return pic; + } + + /* + ==================================================================== + + IMAGE FLOOD FILLING + + ==================================================================== + */ + + /* + ================= + Mod_FloodFillSkin + + Fill background pixels so mipmapping doesn't have haloes + ================= + */ + + static class floodfill_t { + short x, y; + } + + // must be a power of 2 + static final int FLOODFILL_FIFO_SIZE = 0x1000; + static final int FLOODFILL_FIFO_MASK = FLOODFILL_FIFO_SIZE - 1; + // + // #define FLOODFILL_STEP( off, dx, dy ) \ + // { \ + // if (pos[off] == fillcolor) \ + // { \ + // pos[off] = 255; \ + // fifo[inpt].x = x + (dx), fifo[inpt].y = y + (dy); \ + // inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \ + // } \ + // else if (pos[off] != 255) fdc = pos[off]; \ + // } + + // void FLOODFILL_STEP( int off, int dx, int dy ) + // { + // if (pos[off] == fillcolor) + // { + // pos[off] = 255; + // fifo[inpt].x = x + dx; fifo[inpt].y = y + dy; + // inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + // } + // else if (pos[off] != 255) fdc = pos[off]; + // } + static floodfill_t[] fifo = new floodfill_t[FLOODFILL_FIFO_SIZE]; + static { + for (int j = 0; j < fifo.length; j++) { + fifo[j] = new floodfill_t(); + } + } + // TODO check this: R_FloodFillSkin( byte[] skin, int skinwidth, int skinheight) + void R_FloodFillSkin(byte[] skin, int skinwidth, int skinheight) { + // byte fillcolor = *skin; // assume this is the pixel to fill + int fillcolor = skin[0] & 0xff; +// floodfill_t[] fifo = new floodfill_t[FLOODFILL_FIFO_SIZE]; + int inpt = 0, outpt = 0; + int filledcolor = -1; + int i; + +// for (int j = 0; j < fifo.length; j++) { +// fifo[j] = new floodfill_t(); +// } + + if (filledcolor == -1) { + filledcolor = 0; + // attempt to find opaque black + for (i = 0; i < 256; ++i) + // TODO check this + if (d_8to24table[i] == 0xFF000000) { // alpha 1.0 + //if (d_8to24table[i] == (255 << 0)) // alpha 1.0 + filledcolor = i; + break; + } + } + + // can't fill to filled color or to transparent color (used as visited marker) + if ((fillcolor == filledcolor) || (fillcolor == 255)) { + return; + } + + fifo[inpt].x = 0; + fifo[inpt].y = 0; + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + + while (outpt != inpt) { + int x = fifo[outpt].x; + int y = fifo[outpt].y; + int fdc = filledcolor; + // byte *pos = &skin[x + skinwidth * y]; + int pos = x + skinwidth * y; + // + outpt = (outpt + 1) & FLOODFILL_FIFO_MASK; + + int off, dx, dy; + + if (x > 0) { + // FLOODFILL_STEP( -1, -1, 0 ); + off = -1; + dx = -1; + dy = 0; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } + else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + } + + if (x < skinwidth - 1) { + // FLOODFILL_STEP( 1, 1, 0 ); + off = 1; + dx = 1; + dy = 0; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } + else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + } + + if (y > 0) { + // FLOODFILL_STEP( -skinwidth, 0, -1 ); + off = -skinwidth; + dx = 0; + dy = -1; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } + else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + } + + if (y < skinheight - 1) { + // FLOODFILL_STEP( skinwidth, 0, 1 ); + off = skinwidth; + dx = 0; + dy = 1; + if (skin[pos + off] == (byte) fillcolor) { + skin[pos + off] = (byte) 255; + fifo[inpt].x = (short) (x + dx); + fifo[inpt].y = (short) (y + dy); + inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; + } + else if (skin[pos + off] != (byte) 255) + fdc = skin[pos + off] & 0xff; + + } + + skin[x + skinwidth * y] = (byte) fdc; + } + } + + // ======================================================= + + /* + ================ + GL_ResampleTexture + ================ + */ + // cwei :-) + void GL_ResampleTexture(int[] in, int inwidth, int inheight, int[] out, int outwidth, int outheight) { + // int i, j; + // unsigned *inrow, *inrow2; + // int frac, fracstep; + // int[] p1 = new int[1024]; + // int[] p2 = new int[1024]; + // + + // *** this source do the same *** + BufferedImage image = new BufferedImage(inwidth, inheight, BufferedImage.TYPE_INT_ARGB); + + image.setRGB(0, 0, inwidth, inheight, in, 0, inwidth); + + AffineTransformOp op = + new AffineTransformOp( + AffineTransform.getScaleInstance(outwidth * 1.0 / inwidth, outheight * 1.0 / inheight), + AffineTransformOp.TYPE_NEAREST_NEIGHBOR); + BufferedImage tmp = op.filter(image, null); + + tmp.getRGB(0, 0, outwidth, outheight, out, 0, outwidth); + + // *** end *** + + // byte *pix1, *pix2, *pix3, *pix4; + // + // fracstep = inwidth*0x10000/outwidth; + // + // frac = fracstep>>2; + // for (i=0 ; i<outwidth ; i++) + // { + // p1[i] = 4*(frac>>16); + // frac += fracstep; + // } + // frac = 3*(fracstep>>2); + // for (i=0 ; i<outwidth ; i++) + // { + // p2[i] = 4*(frac>>16); + // frac += fracstep; + // } + // + // for (i=0 ; i<outheight ; i++, out += outwidth) + // { + // inrow = in + inwidth*(int)((i+0.25)*inheight/outheight); + // inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight); + // frac = fracstep >> 1; + // for (j=0 ; j<outwidth ; j++) + // { + // pix1 = (byte *)inrow + p1[j]; + // pix2 = (byte *)inrow + p2[j]; + // pix3 = (byte *)inrow2 + p1[j]; + // pix4 = (byte *)inrow2 + p2[j]; + // ((byte *)(out+j))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2; + // ((byte *)(out+j))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2; + // ((byte *)(out+j))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2; + // ((byte *)(out+j))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2; + // } + // } + } + + /* + ================ + GL_LightScaleTexture + + Scale up the pixel values in a texture to increase the + lighting range + ================ + */ + void GL_LightScaleTexture(int[] in, int inwidth, int inheight, boolean only_gamma) { + if (only_gamma) { + int i, c; + int r, g, b, color; + + c = inwidth * inheight; + for (i = 0; i < c; i++) { + color = in[i]; + r = (color >> 0) & 0xFF; + g = (color >> 8) & 0xFF; + b = (color >> 16) & 0xFF; + + r = gammatable[r] & 0xFF; + g = gammatable[g] & 0xFF; + b = gammatable[b] & 0xFF; + + in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000); + } + } + else { + int i, c; + int r, g, b, color; + + c = inwidth * inheight; + for (i = 0; i < c; i++) { + color = in[i]; + r = (color >> 0) & 0xFF; + g = (color >> 8) & 0xFF; + b = (color >> 16) & 0xFF; + + r = gammatable[intensitytable[r] & 0xFF] & 0xFF; + g = gammatable[intensitytable[g] & 0xFF] & 0xFF; + b = gammatable[intensitytable[b] & 0xFF] & 0xFF; + + in[i] = (r << 0) | (g << 8) | (b << 16) | (color & 0xFF000000); + } + + } + } + + /* + ================ + GL_MipMap + + Operates in place, quartering the size of the texture + ================ + */ + void GL_MipMap(int[] in, int width, int height) { + int i, j; + int[] out; + + out = in; + + int inIndex = 0; + int outIndex = 0; + + int r, g, b, a; + int p1, p2, p3, p4; + + for (i = 0; i < height; i += 2, inIndex += width) { + for (j = 0; j < width; j += 2, outIndex += 1, inIndex += 2) { + + p1 = in[inIndex + 0]; + p2 = in[inIndex + 1]; + p3 = in[inIndex + width + 0]; + p4 = in[inIndex + width + 1]; + + r = (((p1 >> 0) & 0xFF) + ((p2 >> 0) & 0xFF) + ((p3 >> 0) & 0xFF) + ((p4 >> 0) & 0xFF)) >> 2; + g = (((p1 >> 8) & 0xFF) + ((p2 >> 8) & 0xFF) + ((p3 >> 8) & 0xFF) + ((p4 >> 8) & 0xFF)) >> 2; + b = (((p1 >> 16) & 0xFF) + ((p2 >> 16) & 0xFF) + ((p3 >> 16) & 0xFF) + ((p4 >> 16) & 0xFF)) >> 2; + a = (((p1 >> 24) & 0xFF) + ((p2 >> 24) & 0xFF) + ((p3 >> 24) & 0xFF) + ((p4 >> 24) & 0xFF)) >> 2; + + out[outIndex] = (r << 0) | (g << 8) | (b << 16) | (a << 24); + } + } + } + + /* + =============== + GL_Upload32 + + Returns has_alpha + =============== + */ + void GL_BuildPalettedTexture(ByteBuffer paletted_texture, int[] scaled, int scaled_width, int scaled_height) { + + int r, g, b, c; + int size = scaled_width * scaled_height; + + for (int i = 0; i < size; i++) { + + r = (scaled[i] >> 3) & 31; + g = (scaled[i] >> 10) & 63; + b = (scaled[i] >> 19) & 31; + + c = r | (g << 5) | (b << 11); + + paletted_texture.put(i, gl_state.d_16to8table[c]); + } + } + + int upload_width, upload_height; + boolean uploaded_paletted; + + /* + =============== + GL_Upload32 + + Returns has_alpha + =============== + */ + int[] scaled = new int[256 * 256]; + //byte[] paletted_texture = new byte[256 * 256]; + ByteBuffer paletted_texture = Lib.newByteBuffer(256*256); + IntBuffer tex = Lib.newIntBuffer(512 * 256, ByteOrder.LITTLE_ENDIAN); + + boolean GL_Upload32(int[] data, int width, int height, boolean mipmap) { + int samples; + int scaled_width, scaled_height; + int i, c; + int comp; + + Arrays.fill(scaled, 0); + // Arrays.fill(paletted_texture, (byte)0); + paletted_texture.clear(); + for (int j=0; j<256*256; j++) paletted_texture.put(j,(byte)0); + + uploaded_paletted = false; + + for (scaled_width = 1; scaled_width < width; scaled_width <<= 1); + if (gl_round_down.value > 0.0f && scaled_width > width && mipmap) + scaled_width >>= 1; + for (scaled_height = 1; scaled_height < height; scaled_height <<= 1); + if (gl_round_down.value > 0.0f && scaled_height > height && mipmap) + scaled_height >>= 1; + + // let people sample down the world textures for speed + if (mipmap) { + scaled_width >>= (int) gl_picmip.value; + scaled_height >>= (int) gl_picmip.value; + } + + // don't ever bother with >256 textures + if (scaled_width > 256) + scaled_width = 256; + if (scaled_height > 256) + scaled_height = 256; + + if (scaled_width < 1) + scaled_width = 1; + if (scaled_height < 1) + scaled_height = 1; + + upload_width = scaled_width; + upload_height = scaled_height; + + if (scaled_width * scaled_height > 256 * 256) + Com.Error(Defines.ERR_DROP, "GL_Upload32: too big"); + + // scan the texture for any non-255 alpha + c = width * height; + samples = gl_solid_format; + + for (i = 0; i < c; i++) { + if ((data[i] & 0xff000000) != 0xff000000) { + samples = gl_alpha_format; + break; + } + } + + if (samples == gl_solid_format) + comp = gl_tex_solid_format; + else if (samples == gl_alpha_format) + comp = gl_tex_alpha_format; + else { + VID.Printf(Defines.PRINT_ALL, "Unknown number of texture components " + samples + '\n'); + comp = samples; + } + + // simulates a goto + try { + if (scaled_width == width && scaled_height == height) { + if (!mipmap) { + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && samples == gl_solid_format) { + uploaded_paletted = true; + GL_BuildPalettedTexture(paletted_texture, data, scaled_width, scaled_height); + gl.glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_COLOR_INDEX8_EXT, + scaled_width, + scaled_height, + 0, + GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, + paletted_texture); + } + else { + tex.rewind(); tex.put(data); tex.rewind(); + gl.glTexImage2D( + GL_TEXTURE_2D, + 0, + comp, + scaled_width, + scaled_height, + 0, + GL_RGBA, + GL_UNSIGNED_BYTE, + tex); + } + //goto done; + throw gotoDone; + } + //memcpy (scaled, data, width*height*4); were bytes + System.arraycopy(data, 0, scaled, 0, width * height); + } + else + GL_ResampleTexture(data, width, height, scaled, scaled_width, scaled_height); + + GL_LightScaleTexture(scaled, scaled_width, scaled_height, !mipmap); + + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && (samples == gl_solid_format)) { + uploaded_paletted = true; + GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, scaled_height); + gl.glTexImage2D( + GL_TEXTURE_2D, + 0, + GL_COLOR_INDEX8_EXT, + scaled_width, + scaled_height, + 0, + GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, + paletted_texture); + } + else { + tex.rewind(); tex.put(scaled); tex.rewind(); + gl.glTexImage2D(GL_TEXTURE_2D, 0, comp, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex); + } + + if (mipmap) { + int miplevel; + miplevel = 0; + while (scaled_width > 1 || scaled_height > 1) { + GL_MipMap(scaled, scaled_width, scaled_height); + scaled_width >>= 1; + scaled_height >>= 1; + if (scaled_width < 1) + scaled_width = 1; + if (scaled_height < 1) + scaled_height = 1; + + miplevel++; + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && samples == gl_solid_format) { + uploaded_paletted = true; + GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, scaled_height); + gl.glTexImage2D( + GL_TEXTURE_2D, + miplevel, + GL_COLOR_INDEX8_EXT, + scaled_width, + scaled_height, + 0, + GL_COLOR_INDEX, + GL_UNSIGNED_BYTE, + paletted_texture); + } + else { + tex.rewind(); tex.put(scaled); tex.rewind(); + gl.glTexImage2D( + GL_TEXTURE_2D, + miplevel, + comp, + scaled_width, + scaled_height, + 0, + GL_RGBA, + GL_UNSIGNED_BYTE, + tex); + } + } + } + // label done: + } + catch (Throwable e) { + // replaces label done + } + + if (mipmap) { + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + } + else { + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + } + + return (samples == gl_alpha_format); + } + + /* + =============== + GL_Upload8 + + Returns has_alpha + =============== + */ + + int[] trans = new int[512 * 256]; + + boolean GL_Upload8(byte[] data, int width, int height, boolean mipmap, boolean is_sky) { + + Arrays.fill(trans, 0); + + int s = width * height; + + if (s > trans.length) + Com.Error(Defines.ERR_DROP, "GL_Upload8: too large"); + + if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && is_sky) { + gl.glTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, width, height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, ByteBuffer.wrap(data)); + + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + + // TODO check this + return false; + } + else { + int p; + int rgb; + for (int i = 0; i < s; i++) { + p = data[i] & 0xff; + trans[i] = d_8to24table[p]; + + if (p == 255) { // transparent, so scan around for another color + // to avoid alpha fringes + // FIXME: do a full flood fill so mips work... + if (i > width && (data[i - width] & 0xff) != 255) + p = data[i - width] & 0xff; + else if (i < s - width && (data[i + width] & 0xff) != 255) + p = data[i + width] & 0xff; + else if (i > 0 && (data[i - 1] & 0xff) != 255) + p = data[i - 1] & 0xff; + else if (i < s - 1 && (data[i + 1] & 0xff) != 255) + p = data[i + 1] & 0xff; + else + p = 0; + // copy rgb components + + // ((byte *)&trans[i])[0] = ((byte *)&d_8to24table[p])[0]; + // ((byte *)&trans[i])[1] = ((byte *)&d_8to24table[p])[1]; + // ((byte *)&trans[i])[2] = ((byte *)&d_8to24table[p])[2]; + + trans[i] = d_8to24table[p] & 0x00FFFFFF; // only rgb + } + } + + return GL_Upload32(trans, width, height, mipmap); + } + } + + /* + ================ + GL_LoadPic + + This is also used as an entry point for the generated r_notexture + ================ + */ + image_t GL_LoadPic(String name, byte[] pic, int width, int height, int type, int bits) { + image_t image; + int i; + + // find a free image_t + for (i = 0; i<numgltextures ; i++) + { + image = gltextures[i]; + if (image.texnum == 0) + break; + } + + if (i == numgltextures) + { + if (numgltextures == MAX_GLTEXTURES) + Com.Error (Defines.ERR_DROP, "MAX_GLTEXTURES"); + + numgltextures++; + } + image = gltextures[i]; + + if (name.length() > Defines.MAX_QPATH) + Com.Error(Defines.ERR_DROP, "Draw_LoadPic: \"" + name + "\" is too long"); + + image.name = name; + image.registration_sequence = registration_sequence; + + image.width = width; + image.height = height; + image.type = type; + + + if (type == it_skin && bits == 8) + R_FloodFillSkin(pic, width, height); + + // load little pics into the scrap + if (image.type == it_pic && bits == 8 && image.width < 64 && image.height < 64) { + pos_t pos = new pos_t(0, 0); + int j, k; + + int texnum = Scrap_AllocBlock(image.width, image.height, pos); + + if (texnum == -1) { + // replace goto nonscrap + + image.scrap = false; + + image.texnum = TEXNUM_IMAGES + image.getId(); // image pos in array + GL_Bind(image.texnum); + + if (bits == 8) { + image.has_alpha = + GL_Upload8(pic, width, height, (image.type != it_pic && image.type != it_sky), image.type == it_sky); + } + else { + int[] tmp = new int[pic.length / 4]; + + for (i = 0; i < tmp.length; i++) { + tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF; + tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00; + tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000; + tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000; + } + + image.has_alpha = GL_Upload32(tmp, width, height, (image.type != it_pic && image.type != it_sky)); + } + + image.upload_width = upload_width; // after power of 2 and scales + image.upload_height = upload_height; + image.paletted = uploaded_paletted; + image.sl = 0; + image.sh = 1; + image.tl = 0; + image.th = 1; + + return image; + } + + scrap_dirty = true; + + // copy the texels into the scrap block + k = 0; + for (i = 0; i < image.height; i++) + for (j = 0; j < image.width; j++, k++) + scrap_texels[texnum][(pos.y + i) * BLOCK_WIDTH + pos.x + j] = pic[k]; + + image.texnum = TEXNUM_SCRAPS + texnum; + image.scrap = true; + image.has_alpha = true; + image.sl = (pos.x + 0.01f) / (float) BLOCK_WIDTH; + image.sh = (pos.x + image.width - 0.01f) / (float) BLOCK_WIDTH; + image.tl = (pos.y + 0.01f) / (float) BLOCK_WIDTH; + image.th = (pos.y + image.height - 0.01f) / (float) BLOCK_WIDTH; + + } + else { + // this was label nonscrap + + image.scrap = false; + + image.texnum = TEXNUM_IMAGES + image.getId(); //image pos in array + GL_Bind(image.texnum); + + if (bits == 8) { + image.has_alpha = GL_Upload8(pic, width, height, (image.type != it_pic && image.type != it_sky), image.type == it_sky); + } + else { + int[] tmp = new int[pic.length / 4]; + + for (i = 0; i < tmp.length; i++) { + tmp[i] = ((pic[4 * i + 0] & 0xFF) << 0); // & 0x000000FF; + tmp[i] |= ((pic[4 * i + 1] & 0xFF) << 8); // & 0x0000FF00; + tmp[i] |= ((pic[4 * i + 2] & 0xFF) << 16); // & 0x00FF0000; + tmp[i] |= ((pic[4 * i + 3] & 0xFF) << 24); // & 0xFF000000; + } + + image.has_alpha = GL_Upload32(tmp, width, height, (image.type != it_pic && image.type != it_sky)); + } + image.upload_width = upload_width; // after power of 2 and scales + image.upload_height = upload_height; + image.paletted = uploaded_paletted; + image.sl = 0; + image.sh = 1; + image.tl = 0; + image.th = 1; + } + return image; + } + + /* + ================ + GL_LoadWal + ================ + */ + image_t GL_LoadWal(String name) { + + image_t image = null; + + byte[] raw = FS.LoadFile(name); + if (raw == null) { + VID.Printf(Defines.PRINT_ALL, "GL_FindImage: can't load " + name + '\n'); + return r_notexture; + } + + qfiles.miptex_t mt = new qfiles.miptex_t(raw); + + byte[] pix = new byte[mt.width * mt.height]; + System.arraycopy(raw, mt.offsets[0], pix, 0, pix.length); + + image = GL_LoadPic(name, pix, mt.width, mt.height, it_wall, 8); + + return image; + } + + Map imageCache = new HashMap(MAX_GLTEXTURES); + + /* + =============== + GL_FindImage + + Finds or loads the given image + =============== + */ + image_t GL_FindImage(String name, int type) { + + if (name == null || name.length() < 5) + return null; + + // look for it + image_t image = (image_t) imageCache.get(name); + if (image != null) { + image.registration_sequence = registration_sequence; + return image; + } + + // + // load the pic from disk + // + image = null; + byte[] pic = null; + Dimension dim = new Dimension(); + + if (name.endsWith(".pcx")) { + + pic = LoadPCX(name, null, dim); + if (pic == null) + return null; + image = GL_LoadPic(name, pic, dim.width, dim.height, type, 8); + + } + else if (name.endsWith(".wal")) { + + image = GL_LoadWal(name); + + } + else if (name.endsWith(".tga")) { + + pic = LoadTGA(name, dim); + + if (pic == null) + return null; + + image = GL_LoadPic(name, pic, dim.width, dim.height, type, 32); + + } + + imageCache.put(image.name, image); + return image; + } + + /* + =============== + R_RegisterSkin + =============== + */ + public image_t R_RegisterSkin(String name) { + return GL_FindImage(name, it_skin); + } + + IntBuffer texnumBuffer=Lib.newIntBuffer(1); + + /* + ================ + GL_FreeUnusedImages + + Any image that was not touched on this registration sequence + will be freed. + ================ + */ + void GL_FreeUnusedImages() { + + // never free r_notexture or particle texture + r_notexture.registration_sequence = registration_sequence; + r_particletexture.registration_sequence = registration_sequence; + + image_t image = null; + + for (int i = 0; i < numgltextures; i++) { + image = gltextures[i]; + // used this sequence + if (image.registration_sequence == registration_sequence) + continue; + // free image_t slot + if (image.registration_sequence == 0) + continue; + // don't free pics + if (image.type == it_pic) + continue; + + // free it + texnumBuffer.clear(); + texnumBuffer.put(0,image.texnum); + gl.glDeleteTextures(texnumBuffer); + + imageCache.remove(image.name); + image.clear(); + } + } + + /* + =============== + Draw_GetPalette + =============== + */ + protected void Draw_GetPalette() { + int r, g, b; + byte[][] palette = new byte[1][]; //new byte[768]; + + // get the palette + + LoadPCX("pics/colormap.pcx", palette, null); + + if (palette[0] == null || palette[0].length != 768) + Com.Error(Defines.ERR_FATAL, "Couldn't load pics/colormap.pcx"); + + byte[] pal = palette[0]; + + int j = 0; + for (int i = 0; i < 256; i++) { + r = pal[j++] & 0xFF; + g = pal[j++] & 0xFF; + b = pal[j++] & 0xFF; + + d_8to24table[i] = (255 << 24) | (b << 16) | (g << 8) | (r << 0); + } + + d_8to24table[255] &= 0x00FFFFFF; // 255 is transparent + + particle_t.setColorPalette(d_8to24table); + } + + /* + =============== + GL_InitImages + =============== + */ + void GL_InitImages() { + int i, j; + float g = vid_gamma.value; + + registration_sequence = 1; + + // init intensity conversions + intensity = Cvar.Get("intensity", "2", 0); + + if (intensity.value <= 1) + Cvar.Set("intensity", "1"); + + gl_state.inverse_intensity = 1 / intensity.value; + + Draw_GetPalette(); + + if (qglColorTableEXT) { + gl_state.d_16to8table = FS.LoadFile("pics/16to8.dat"); + if (gl_state.d_16to8table == null) + Com.Error(Defines.ERR_FATAL, "Couldn't load pics/16to8.pcx"); + } + + if ((gl_config.renderer & (GL_RENDERER_VOODOO | GL_RENDERER_VOODOO2)) != 0) { + g = 1.0F; + } + + for (i = 0; i < 256; i++) { + + if (g == 1.0f) { + gammatable[i] = (byte) i; + } + else { + + int inf = (int) (255.0f * Math.pow((i + 0.5) / 255.5, g) + 0.5); + if (inf < 0) + inf = 0; + if (inf > 255) + inf = 255; + gammatable[i] = (byte) inf; + } + } + + for (i = 0; i < 256; i++) { + j = (int) (i * intensity.value); + if (j > 255) + j = 255; + intensitytable[i] = (byte) j; + } + } + + /* + =============== + GL_ShutdownImages + =============== + */ + void GL_ShutdownImages() { + image_t image; + + for (int i=0; i < numgltextures ; i++) + { + image = gltextures[i]; + + if (image.registration_sequence == 0) + continue; // free image_t slot + + // free it + texnumBuffer.clear(); + texnumBuffer.put(0,image.texnum); + gl.glDeleteTextures(texnumBuffer); + + imageCache.remove(image.name); + image.clear(); + } + } + +} diff --git a/src/jake2/render/fast/Light.java b/src/jake2/render/fast/Light.java new file mode 100644 index 0000000..c0d0a32 --- /dev/null +++ b/src/jake2/render/fast/Light.java @@ -0,0 +1,752 @@ +/* + * Light.java + * Copyright (C) 2003 + * + * $Id: Light.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.Globals; +import jake2.client.dlight_t; +import jake2.game.cplane_t; +import jake2.qcommon.Com; +import jake2.render.*; +import jake2.util.Math3D; +import jake2.util.Vec3Cache; + +import java.nio.ByteBuffer; +import java.nio.IntBuffer; +import java.util.Arrays; + +/** + * Light + * + * @author cwei + */ +public abstract class Light extends Warp { + // r_light.c + + int r_dlightframecount; + + static final int DLIGHT_CUTOFF = 64; + + /* + ============================================================================= + + DYNAMIC LIGHTS BLEND RENDERING + + ============================================================================= + */ + + // stack variable + private final float[] v = {0, 0, 0}; + /** + * R_RenderDlight + */ + void R_RenderDlight(dlight_t light) + { + float rad = light.intensity * 0.35f; + + Math3D.VectorSubtract (light.origin, r_origin, v); + + gl.glBegin (GL_TRIANGLE_FAN); + gl.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; + + gl.glVertex3f(v[0], v[1], v[2]); + gl.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); + gl.glVertex3f(v[0], v[1], v[2]); + } + gl.glEnd (); + } + + /** + * R_RenderDlights + */ + void R_RenderDlights() + { + if (gl_flashblend.value == 0) + return; + + r_dlightframecount = r_framecount + 1; // because the count hasn't + // advanced yet for this frame + gl.glDepthMask(false); + gl.glDisable(GL_TEXTURE_2D); + gl.glShadeModel (GL_SMOOTH); + gl.glEnable (GL_BLEND); + gl.glBlendFunc (GL_ONE, GL_ONE); + + for (int i=0 ; i<r_newrefdef.num_dlights ; i++) + { + R_RenderDlight(r_newrefdef.dlights[i]); + } + + gl.glColor3f (1,1,1); + gl.glDisable(GL_BLEND); + gl.glEnable(GL_TEXTURE_2D); + gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl.glDepthMask(true); + } + + + /* + ============================================================================= + + DYNAMIC LIGHTS + + ============================================================================= + */ + + /** + * R_MarkLights + */ + void R_MarkLights (dlight_t light, int bit, mnode_t node) + { + if (node.contents != -1) + return; + + cplane_t splitplane = node.plane; + float dist = Math3D.DotProduct (light.origin, splitplane.normal) - splitplane.dist; + + if (dist > light.intensity - DLIGHT_CUTOFF) + { + R_MarkLights (light, bit, node.children[0]); + return; + } + if (dist < -light.intensity + DLIGHT_CUTOFF) + { + R_MarkLights (light, bit, node.children[1]); + return; + } + + // mark the polygons + msurface_t surf; + int sidebit; + for (int i=0 ; i<node.numsurfaces ; i++) + { + + surf = r_worldmodel.surfaces[node.firstsurface + i]; + + /* + * cwei + * bugfix for dlight behind the walls + */ + dist = Math3D.DotProduct (light.origin, surf.plane.normal) - surf.plane.dist; + sidebit = (dist >= 0) ? 0 : Defines.SURF_PLANEBACK; + if ( (surf.flags & Defines.SURF_PLANEBACK) != sidebit ) + continue; + /* + * cwei + * bugfix end + */ + + if (surf.dlightframe != r_dlightframecount) + { + surf.dlightbits = 0; + surf.dlightframe = r_dlightframecount; + } + surf.dlightbits |= bit; + } + + R_MarkLights (light, bit, node.children[0]); + R_MarkLights (light, bit, node.children[1]); + } + + /** + * R_PushDlights + */ + void R_PushDlights() + { + if (gl_flashblend.value != 0) + return; + + r_dlightframecount = r_framecount + 1; // because the count hasn't + // advanced yet for this frame + dlight_t l; + for (int i=0 ; i<r_newrefdef.num_dlights ; i++) { + l = r_newrefdef.dlights[i]; + R_MarkLights( l, 1<<i, r_worldmodel.nodes[0] ); + } + } + + /* + ============================================================================= + + LIGHT SAMPLING + + ============================================================================= + */ + + float[] pointcolor = {0, 0, 0}; // vec3_t + cplane_t lightplane; // used as shadow plane + float[] lightspot = {0, 0, 0}; // vec3_t + + /** + * RecursiveLightPoint + * @param node + * @param start + * @param end + * @return + */ + int RecursiveLightPoint (mnode_t node, float[] start, float[] end) + { + if (node.contents != -1) + return -1; // didn't hit anything + + // calculate mid point + + // FIXME: optimize for axial + cplane_t plane = node.plane; + float front = Math3D.DotProduct (start, plane.normal) - plane.dist; + float back = Math3D.DotProduct (end, plane.normal) - plane.dist; + boolean side = (front < 0); + int sideIndex = (side) ? 1 : 0; + + if ( (back < 0) == side) + return RecursiveLightPoint (node.children[sideIndex], start, end); + + float frac = front / (front-back); + float[] mid = Vec3Cache.get(); + mid[0] = start[0] + (end[0] - start[0])*frac; + mid[1] = start[1] + (end[1] - start[1])*frac; + mid[2] = start[2] + (end[2] - start[2])*frac; + + // go down front side + int r = RecursiveLightPoint (node.children[sideIndex], start, mid); + if (r >= 0) { + Vec3Cache.release(); // mid + return r; // hit something + } + + if ( (back < 0) == side ) { + Vec3Cache.release(); // mid + return -1; // didn't hit anuthing + } + + // check for impact on this node + Math3D.VectorCopy (mid, lightspot); + lightplane = plane; + int surfIndex = node.firstsurface; + + msurface_t surf; + int s, t, ds, dt; + mtexinfo_t tex; + ByteBuffer lightmap; + int maps; + for (int i=0 ; i<node.numsurfaces ; i++, surfIndex++) + { + surf = r_worldmodel.surfaces[surfIndex]; + + if ((surf.flags & (Defines.SURF_DRAWTURB | Defines.SURF_DRAWSKY)) != 0) + continue; // no lightmaps + + tex = surf.texinfo; + + s = (int)(Math3D.DotProduct (mid, tex.vecs[0]) + tex.vecs[0][3]); + t = (int)(Math3D.DotProduct (mid, tex.vecs[1]) + tex.vecs[1][3]); + + if (s < surf.texturemins[0] || t < surf.texturemins[1]) + continue; + + ds = s - surf.texturemins[0]; + dt = t - surf.texturemins[1]; + + if ( ds > surf.extents[0] || dt > surf.extents[1] ) + continue; + + if (surf.samples == null) + return 0; + + ds >>= 4; + dt >>= 4; + + lightmap = surf.samples; + int lightmapIndex = 0; + + Math3D.VectorCopy (Globals.vec3_origin, pointcolor); + if (lightmap != null) + { + float[] rgb; + lightmapIndex += 3 * (dt * ((surf.extents[0] >> 4) + 1) + ds); + + float scale0, scale1, scale2; + for (maps = 0 ; maps < Defines.MAXLIGHTMAPS && surf.styles[maps] != (byte)255; maps++) + { + rgb = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb; + scale0 = gl_modulate.value * rgb[0]; + scale1 = gl_modulate.value * rgb[1]; + scale2 = gl_modulate.value * rgb[2]; + + pointcolor[0] += (lightmap.get(lightmapIndex + 0) & 0xFF) * scale0 * (1.0f/255); + pointcolor[1] += (lightmap.get(lightmapIndex + 1) & 0xFF) * scale1 * (1.0f/255); + pointcolor[2] += (lightmap.get(lightmapIndex + 2) & 0xFF) * scale2 * (1.0f/255); + lightmapIndex += 3 * ((surf.extents[0] >> 4) + 1) * ((surf.extents[1] >> 4) + 1); + } + } + Vec3Cache.release(); // mid + return 1; + } + + // go down back side + r = RecursiveLightPoint (node.children[1 - sideIndex], mid, end); + Vec3Cache.release(); // mid + return r; + } + + // stack variable + private final float[] end = {0, 0, 0}; + /** + * R_LightPoint + */ + void R_LightPoint (float[] p, float[] color) + { + assert (p.length == 3) : "vec3_t bug"; + assert (color.length == 3) : "rgb bug"; + + if (r_worldmodel.lightdata == null) + { + color[0] = color[1] = color[2] = 1.0f; + return; + } + + end[0] = p[0]; + end[1] = p[1]; + end[2] = p[2] - 2048; + + float r = RecursiveLightPoint(r_worldmodel.nodes[0], p, end); + + if (r == -1) + { + Math3D.VectorCopy (Globals.vec3_origin, color); + } + else + { + Math3D.VectorCopy (pointcolor, color); + } + + // + // add dynamic lights + // + dlight_t dl; + float add; + for (int lnum=0 ; lnum<r_newrefdef.num_dlights ; lnum++) + { + dl = r_newrefdef.dlights[lnum]; + + Math3D.VectorSubtract (currententity.origin, dl.origin, end); + add = dl.intensity - Math3D.VectorLength(end); + add *= (1.0f/256); + if (add > 0) + { + Math3D.VectorMA (color, add, dl.color, color); + } + } + Math3D.VectorScale (color, gl_modulate.value, color); + } + +// =================================================================== + + float[] s_blocklights = new float[34 * 34 * 3]; + +// TODO sync with jogl renderer. hoz + private final float[] impact = {0, 0, 0}; + /** + * R_AddDynamicLights + */ + void R_AddDynamicLights(msurface_t surf) + { + int sd, td; + float fdist, frad, fminlight; + int s, t; + dlight_t dl; + float[] pfBL; + float fsacc, ftacc; + + int smax = (surf.extents[0]>>4)+1; + int tmax = (surf.extents[1]>>4)+1; + mtexinfo_t tex = surf.texinfo; + + float local0, local1; + for (int lnum=0 ; lnum<r_newrefdef.num_dlights ; lnum++) + { + if ( (surf.dlightbits & (1<<lnum)) == 0 ) + continue; // not lit by this light + + dl = r_newrefdef.dlights[lnum]; + frad = dl.intensity; + fdist = Math3D.DotProduct (dl.origin, surf.plane.normal) - + surf.plane.dist; + frad -= Math.abs(fdist); + // rad is now the highest intensity on the plane + + fminlight = DLIGHT_CUTOFF; // FIXME: make configurable? + if (frad < fminlight) + continue; + fminlight = frad - fminlight; + + for (int i=0 ; i<3 ; i++) + { + impact[i] = dl.origin[i] - + surf.plane.normal[i]*fdist; + } + + local0 = Math3D.DotProduct (impact, tex.vecs[0]) + tex.vecs[0][3] - surf.texturemins[0]; + local1 = Math3D.DotProduct (impact, tex.vecs[1]) + tex.vecs[1][3] - surf.texturemins[1]; + + pfBL = s_blocklights; + int pfBLindex = 0; + for (t = 0, ftacc = 0 ; t<tmax ; t++, ftacc += 16) + { + td = (int)(local1 - ftacc); + if ( td < 0 ) + td = -td; + + for (s=0, fsacc = 0 ; s<smax ; s++, fsacc += 16, pfBLindex += 3) + { + sd = (int)( local0 - fsacc ); + + if ( sd < 0 ) + sd = -sd; + + if (sd > td) + fdist = sd + (td>>1); + else + fdist = td + (sd>>1); + + if ( fdist < fminlight ) + { + pfBL[pfBLindex + 0] += ( frad - fdist ) * dl.color[0]; + pfBL[pfBLindex + 1] += ( frad - fdist ) * dl.color[1]; + pfBL[pfBLindex + 2] += ( frad - fdist ) * dl.color[2]; + } + } + } + } + } + + /** + * R_SetCacheState + */ + void R_SetCacheState( msurface_t surf ) + { + for (int maps = 0 ; maps < Defines.MAXLIGHTMAPS && surf.styles[maps] != (byte)255 ; maps++) + { + surf.cached_light[maps] = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].white; + } + } + + private Throwable gotoStore = new Throwable(); + +// TODO sync with jogl renderer. hoz + /** + * R_BuildLightMap + * + * Combine and scale multiple lightmaps into the floating format in blocklights + */ + void R_BuildLightMap(msurface_t surf, IntBuffer dest, int stride) + { + int r, g, b, a, max; + int i, j; + int nummaps; + float[] bl; + //lightstyle_t style; + + if ((surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 + | Defines.SURF_TRANS66 | Defines.SURF_WARP)) != 0) + Com.Error(Defines.ERR_DROP, + "R_BuildLightMap called for non-lit surface"); + + int smax = (surf.extents[0] >> 4) + 1; + int tmax = (surf.extents[1] >> 4) + 1; + int size = smax * tmax; + if (size > ((s_blocklights.length * Defines.SIZE_OF_FLOAT) >> 4)) + Com.Error(Defines.ERR_DROP, "Bad s_blocklights size"); + + try { + // set to full bright if no light data + if (surf.samples == null) { + int maps; + + for (i = 0; i < size * 3; i++) + s_blocklights[i] = 255; + + // TODO useless? hoz + // for (maps = 0 ; maps < Defines.MAXLIGHTMAPS && + // surf.styles[maps] != (byte)255; maps++) + // { + // style = r_newrefdef.lightstyles[surf.styles[maps] & 0xFF]; + // } + + // goto store; + throw gotoStore; + } + + // count the # of maps + for (nummaps = 0; nummaps < Defines.MAXLIGHTMAPS + && surf.styles[nummaps] != (byte) 255; nummaps++) + ; + + ByteBuffer lightmap = surf.samples; + int lightmapIndex = 0; + + // add all the lightmaps + float scale0; + float scale1; + float scale2; + if (nummaps == 1) { + int maps; + + for (maps = 0; maps < Defines.MAXLIGHTMAPS + && surf.styles[maps] != (byte) 255; maps++) { + bl = s_blocklights; + int blp = 0; + +// for (i = 0; i < 3; i++) +// scale[i] = gl_modulate.value +// * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i]; + scale0 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[0]; + scale1 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[1]; + scale2 = gl_modulate.value * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[2]; + + if (scale0 == 1.0F && scale1 == 1.0F + && scale2 == 1.0F) { + for (i = 0; i < size; i++) { + bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] = lightmap.get(lightmapIndex++) & 0xFF; + } + } else { + for (i = 0; i < size; i++) { + bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) + * scale0; + bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) + * scale1; + bl[blp++] = (lightmap.get(lightmapIndex++) & 0xFF) + * scale2; + } + } + //lightmap += size*3; // skip to next lightmap + } + } else { + int maps; + + // memset( s_blocklights, 0, sizeof( s_blocklights[0] ) * size * + // 3 ); + + Arrays.fill(s_blocklights, 0, size * 3, 0.0f); + + for (maps = 0; maps < Defines.MAXLIGHTMAPS + && surf.styles[maps] != (byte) 255; maps++) { + bl = s_blocklights; + int blp = 0; + +// for (i = 0; i < 3; i++) +// scale[i] = gl_modulate.value +// * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[i]; + scale0 = gl_modulate.value + * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[0]; + scale1 = gl_modulate.value + * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[1]; + scale2 = gl_modulate.value + * r_newrefdef.lightstyles[surf.styles[maps] & 0xFF].rgb[2]; + + + + + if (scale0 == 1.0F && scale1 == 1.0F + && scale2 == 1.0F) { + for (i = 0; i < size; i++) { + bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; + bl[blp++] += lightmap.get(lightmapIndex++) & 0xFF; + } + } else { + for (i = 0; i < size; i++) { + bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) + * scale0; + bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) + * scale1; + bl[blp++] += (lightmap.get(lightmapIndex++) & 0xFF) + * scale2; + } + } + //lightmap += size*3; // skip to next lightmap + } + } + + // add all the dynamic lights + if (surf.dlightframe == r_framecount) + R_AddDynamicLights(surf); + + // label store: + } catch (Throwable store) { + } + + // put into texture format + stride -= smax; + bl = s_blocklights; + int blp = 0; + + int monolightmap = gl_monolightmap.string.charAt(0); + + int destp = 0; + + if (monolightmap == '0') { + for (i = 0; i < tmax; i++, destp += stride) { + for (j = 0; j < smax; j++) { + + r = (int) bl[blp++]; + g = (int) bl[blp++]; + b = (int) bl[blp++]; + + // catch negative lights + if (r < 0) + r = 0; + if (g < 0) + g = 0; + if (b < 0) + b = 0; + + /* + * * determine the brightest of the three color components + */ + if (r > g) + max = r; + else + max = g; + if (b > max) + max = b; + + /* + * * alpha is ONLY used for the mono lightmap case. For this + * reason * we set it to the brightest of the color + * components so that * things don't get too dim. + */ + a = max; + + /* + * * rescale all the color components if the intensity of + * the greatest * channel exceeds 1.0 + */ + if (max > 255) { + float t = 255.0F / max; + + r = (int) (r * t); + g = (int) (g * t); + b = (int) (b * t); + a = (int) (a * t); + } + //r &= 0xFF; g &= 0xFF; b &= 0xFF; a &= 0xFF; + dest.put(destp++, (a << 24) | (b << 16) | (g << 8) | r); + } + } + } else { + for (i = 0; i < tmax; i++, destp += stride) { + for (j = 0; j < smax; j++) { + + r = (int) bl[blp++]; + g = (int) bl[blp++]; + b = (int) bl[blp++]; + + // catch negative lights + if (r < 0) + r = 0; + if (g < 0) + g = 0; + if (b < 0) + b = 0; + + /* + * * determine the brightest of the three color components + */ + if (r > g) + max = r; + else + max = g; + if (b > max) + max = b; + + /* + * * alpha is ONLY used for the mono lightmap case. For this + * reason * we set it to the brightest of the color + * components so that * things don't get too dim. + */ + a = max; + + /* + * * rescale all the color components if the intensity of + * the greatest * channel exceeds 1.0 + */ + if (max > 255) { + float t = 255.0F / max; + + r = (int) (r * t); + g = (int) (g * t); + b = (int) (b * t); + a = (int) (a * t); + } + + /* + * * So if we are doing alpha lightmaps we need to set the + * R, G, and B * components to 0 and we need to set alpha to + * 1-alpha. + */ + switch (monolightmap) { + case 'L': + case 'I': + r = a; + g = b = 0; + break; + case 'C': + // try faking colored lighting + a = 255 - ((r + g + b) / 3); + float af = a / 255.0f; + r *= af; + g *= af; + b *= af; + break; + case 'A': + default: + r = g = b = 0; + a = 255 - a; + break; + } + //r &= 0xFF; g &= 0xFF; b &= 0xFF; a &= 0xFF; + dest.put(destp++, (a << 24) | (b << 16) | (g << 8) | r); + } + } + } + } + +}
\ No newline at end of file diff --git a/src/jake2/render/fast/Main.java b/src/jake2/render/fast/Main.java new file mode 100644 index 0000000..9a4cacf --- /dev/null +++ b/src/jake2/render/fast/Main.java @@ -0,0 +1,1526 @@ +/* + * Main.java + * Copyright (C) 2003 + * + * $Id: Main.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.Globals; +import jake2.client.*; +import jake2.game.*; +import jake2.qcommon.*; +import jake2.render.*; +import jake2.util.*; + +import java.awt.Dimension; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; + +/** + * Main + * + * @author cwei + */ +public abstract class Main extends Base { + + public static int[] d_8to24table = new int[256]; + + int c_visible_lightmaps; + int c_visible_textures; + + int registration_sequence; + + // this a hack for function pointer test + // default disabled + boolean qglColorTableEXT = false; + boolean qglActiveTextureARB = false; + boolean qglPointParameterfEXT = false; + boolean qglLockArraysEXT = false; + boolean qwglSwapIntervalEXT = false; + + // ================= + // abstract methods + // ================= + protected abstract void Draw_GetPalette(); + + abstract void GL_ImageList_f(); + abstract void GL_ScreenShot_f(); + abstract void GL_SetTexturePalette(int[] palette); + abstract void GL_Strings_f(); + + abstract void Mod_Modellist_f(); + abstract mleaf_t Mod_PointInLeaf(float[] point, model_t model); + + abstract void GL_SetDefaultState(); + + abstract void GL_InitImages(); + abstract void Mod_Init(); // Model.java + abstract void R_InitParticleTexture(); // MIsc.java + abstract void R_DrawAliasModel(entity_t e); // Mesh.java + abstract void R_DrawBrushModel(entity_t e); // Surf.java + abstract void Draw_InitLocal(); + abstract void R_LightPoint(float[] p, float[] color); + abstract void R_PushDlights(); + abstract void R_MarkLeaves(); + abstract void R_DrawWorld(); + abstract void R_RenderDlights(); + abstract void R_DrawAlphaSurfaces(); + + abstract void Mod_FreeAll(); + + abstract void GL_ShutdownImages(); + abstract void GL_Bind(int texnum); + abstract void GL_TexEnv(int mode); + abstract void GL_TextureMode(String string); + abstract void GL_TextureAlphaMode(String string); + abstract void GL_TextureSolidMode(String string); + abstract void GL_UpdateSwapInterval(); + + /* + ==================================================================== + + from gl_rmain.c + + ==================================================================== + */ + + int TEXTURE0 = GL_TEXTURE0; + int TEXTURE1 = GL_TEXTURE1; + + model_t r_worldmodel; + + float gldepthmin, gldepthmax; + + glconfig_t gl_config = new glconfig_t(); + glstate_t gl_state = new glstate_t(); + + image_t r_notexture; // use for bad textures + image_t r_particletexture; // little dot for particles + + entity_t currententity; + model_t currentmodel; + + cplane_t frustum[] = { new cplane_t(), new cplane_t(), new cplane_t(), new cplane_t()}; + + int r_visframecount; // bumped when going to a new PVS + int r_framecount; // used for dlight push checking + + int c_brush_polys, c_alias_polys; + + float v_blend[] = { 0, 0, 0, 0 }; // final blending color + + // + // view origin + // + float[] vup = { 0, 0, 0 }; + float[] vpn = { 0, 0, 0 }; + float[] vright = { 0, 0, 0 }; + float[] r_origin = { 0, 0, 0 }; + + //float r_world_matrix[] = new float[16]; + FloatBuffer r_world_matrix = Lib.newFloatBuffer(16); + + float r_base_world_matrix[] = new float[16]; + + // + // screen size info + // + refdef_t r_newrefdef = new refdef_t(); + + int r_viewcluster, r_viewcluster2, r_oldviewcluster, r_oldviewcluster2; + + cvar_t r_norefresh; + cvar_t r_drawentities; + cvar_t r_drawworld; + cvar_t r_speeds; + cvar_t r_fullbright; + cvar_t r_novis; + cvar_t r_nocull; + cvar_t r_lerpmodels; + cvar_t r_lefthand; + + cvar_t r_lightlevel; + // FIXME: This is a HACK to get the client's light level + + cvar_t gl_nosubimage; + cvar_t gl_allow_software; + + cvar_t gl_vertex_arrays; + + cvar_t gl_particle_min_size; + cvar_t gl_particle_max_size; + cvar_t gl_particle_size; + cvar_t gl_particle_att_a; + cvar_t gl_particle_att_b; + cvar_t gl_particle_att_c; + + cvar_t gl_ext_swapinterval; + cvar_t gl_ext_palettedtexture; + cvar_t gl_ext_multitexture; + cvar_t gl_ext_pointparameters; + cvar_t gl_ext_compiled_vertex_array; + + cvar_t gl_log; + cvar_t gl_bitdepth; + cvar_t gl_drawbuffer; + cvar_t gl_driver; + cvar_t gl_lightmap; + cvar_t gl_shadows; + cvar_t gl_mode; + cvar_t gl_dynamic; + cvar_t gl_monolightmap; + cvar_t gl_modulate; + cvar_t gl_nobind; + cvar_t gl_round_down; + cvar_t gl_picmip; + cvar_t gl_skymip; + cvar_t gl_showtris; + cvar_t gl_ztrick; + cvar_t gl_finish; + cvar_t gl_clear; + cvar_t gl_cull; + cvar_t gl_polyblend; + cvar_t gl_flashblend; + cvar_t gl_playermip; + cvar_t gl_saturatelighting; + cvar_t gl_swapinterval; + cvar_t gl_texturemode; + cvar_t gl_texturealphamode; + cvar_t gl_texturesolidmode; + cvar_t gl_lockpvs; + + cvar_t gl_3dlabs_broken; + + cvar_t vid_gamma; + cvar_t vid_ref; + + // ============================================================================ + // to port from gl_rmain.c, ... + // ============================================================================ + + /** + * R_CullBox + * Returns true if the box is completely outside the frustum + */ + final boolean R_CullBox(float[] mins, float[] maxs) { + assert(mins.length == 3 && maxs.length == 3) : "vec3_t bug"; + + if (r_nocull.value != 0) + return false; + + for (int i = 0; i < 4; i++) { + if (Math3D.BoxOnPlaneSide(mins, maxs, frustum[i]) == 2) + return true; + } + return false; + } + + /** + * R_RotateForEntity + */ + final void R_RotateForEntity(entity_t e) { + gl.glTranslatef(e.origin[0], e.origin[1], e.origin[2]); + + gl.glRotatef(e.angles[1], 0, 0, 1); + gl.glRotatef(-e.angles[0], 0, 1, 0); + gl.glRotatef(-e.angles[2], 1, 0, 0); + } + + /* + ============================================================= + + SPRITE MODELS + + ============================================================= + */ + + // stack variable + private final float[] point = { 0, 0, 0 }; + /** + * R_DrawSpriteModel + */ + 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) + gl.glEnable(GL_BLEND); + + gl.glColor4f(1, 1, 1, alpha); + + GL_Bind(currentmodel.skins[e.frame].texnum); + + GL_TexEnv(GL_MODULATE); + + if (alpha == 1.0) + gl.glEnable(GL_ALPHA_TEST); + else + gl.glDisable(GL_ALPHA_TEST); + + gl.glBegin(GL_QUADS); + + gl.glTexCoord2f(0, 1); + Math3D.VectorMA(e.origin, -frame.origin_y, vup, point); + Math3D.VectorMA(point, -frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glTexCoord2f(0, 0); + Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point); + Math3D.VectorMA(point, -frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glTexCoord2f(1, 0); + Math3D.VectorMA(e.origin, frame.height - frame.origin_y, vup, point); + Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glTexCoord2f(1, 1); + Math3D.VectorMA(e.origin, -frame.origin_y, vup, point); + Math3D.VectorMA(point, frame.width - frame.origin_x, vright, point); + gl.glVertex3f(point[0], point[1], point[2]); + + gl.glEnd(); + + gl.glDisable(GL_ALPHA_TEST); + GL_TexEnv(GL_REPLACE); + + if (alpha != 1.0F) + gl.glDisable(GL_BLEND); + + gl.glColor4f(1, 1, 1, 1); + } + + // ================================================================================== + + // stack variable + private final float[] shadelight = { 0, 0, 0 }; + /** + * R_DrawNullModel + */ + void R_DrawNullModel() { + if ((currententity.flags & Defines.RF_FULLBRIGHT) != 0) { + // cwei wollte blau: shadelight[0] = shadelight[1] = shadelight[2] = 1.0F; + shadelight[0] = shadelight[1] = shadelight[2] = 0.0F; + shadelight[2] = 0.8F; + } + else { + R_LightPoint(currententity.origin, shadelight); + } + + gl.glPushMatrix(); + R_RotateForEntity(currententity); + + gl.glDisable(GL_TEXTURE_2D); + gl.glColor3f(shadelight[0], shadelight[1], shadelight[2]); + + // this replaces the TRIANGLE_FAN + //glut.glutWireCube(gl, 20); + + gl.glBegin(GL_TRIANGLE_FAN); + gl.glVertex3f(0, 0, -16); + int i; + for (i=0 ; i<=4 ; i++) { + gl.glVertex3f((float)(16.0f * Math.cos(i * Math.PI / 2)), (float)(16.0f * Math.sin(i * Math.PI / 2)), 0.0f); + } + gl.glEnd(); + + gl.glBegin(GL_TRIANGLE_FAN); + gl.glVertex3f (0, 0, 16); + for (i=4 ; i>=0 ; i--) { + gl.glVertex3f((float)(16.0f * Math.cos(i * Math.PI / 2)), (float)(16.0f * Math.sin(i * Math.PI / 2)), 0.0f); + } + gl.glEnd(); + + + gl.glColor3f(1, 1, 1); + gl.glPopMatrix(); + gl.glEnable(GL_TEXTURE_2D); + } + + /** + * R_DrawEntitiesOnList + */ + void R_DrawEntitiesOnList() { + if (r_drawentities.value == 0.0f) + return; + + // draw non-transparent first + int i; + for (i = 0; i < r_newrefdef.num_entities; i++) { + currententity = r_newrefdef.entities[i]; + if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) + continue; // solid + + if ((currententity.flags & Defines.RF_BEAM) != 0) { + R_DrawBeam(currententity); + } + else { + currentmodel = currententity.model; + if (currentmodel == null) { + R_DrawNullModel(); + continue; + } + switch (currentmodel.type) { + case mod_alias : + R_DrawAliasModel(currententity); + break; + case mod_brush : + R_DrawBrushModel(currententity); + break; + case mod_sprite : + R_DrawSpriteModel(currententity); + break; + default : + Com.Error(Defines.ERR_DROP, "Bad modeltype"); + break; + } + } + } + // draw transparent entities + // we could sort these if it ever becomes a problem... + gl.glDepthMask(false); // no z writes + for (i = 0; i < r_newrefdef.num_entities; i++) { + currententity = r_newrefdef.entities[i]; + if ((currententity.flags & Defines.RF_TRANSLUCENT) == 0) + continue; // solid + + if ((currententity.flags & Defines.RF_BEAM) != 0) { + R_DrawBeam(currententity); + } + else { + currentmodel = currententity.model; + + if (currentmodel == null) { + R_DrawNullModel(); + continue; + } + switch (currentmodel.type) { + case mod_alias : + R_DrawAliasModel(currententity); + break; + case mod_brush : + R_DrawBrushModel(currententity); + break; + case mod_sprite : + R_DrawSpriteModel(currententity); + break; + default : + Com.Error(Defines.ERR_DROP, "Bad modeltype"); + break; + } + } + } + gl.glDepthMask(true); // back to writing + } + + // stack variable + private final float[] up = { 0, 0, 0 }; + private final float[] right = { 0, 0, 0 }; + /** + * GL_DrawParticles + */ + void GL_DrawParticles(int num_particles) { + float origin_x, origin_y, origin_z; + + Math3D.VectorScale(vup, 1.5f, up); + Math3D.VectorScale(vright, 1.5f, right); + + GL_Bind(r_particletexture.texnum); + gl.glDepthMask(false); // no z buffering + gl.glEnable(GL_BLEND); + GL_TexEnv(GL_MODULATE); + + gl.glBegin(GL_TRIANGLES); + + FloatBuffer sourceVertices = particle_t.vertexArray; + IntBuffer sourceColors = particle_t.colorArray; + float scale; + int color; + for (int j = 0, i = 0; i < num_particles; i++) { + origin_x = sourceVertices.get(j++); + origin_y = sourceVertices.get(j++); + origin_z = sourceVertices.get(j++); + + // hack a scale up to keep particles from disapearing + scale = + (origin_x - r_origin[0]) * vpn[0] + + (origin_y - r_origin[1]) * vpn[1] + + (origin_z - r_origin[2]) * vpn[2]; + + scale = (scale < 20) ? 1 : 1 + scale * 0.004f; + + color = sourceColors.get(i); + + gl.glColor4ub( + (byte)((color) & 0xFF), + (byte)((color >> 8) & 0xFF), + (byte)((color >> 16) & 0xFF), + (byte)((color >>> 24)) + ); + // first vertex + gl.glTexCoord2f(0.0625f, 0.0625f); + gl.glVertex3f(origin_x, origin_y, origin_z); + // second vertex + gl.glTexCoord2f(1.0625f, 0.0625f); + gl.glVertex3f(origin_x + up[0] * scale, origin_y + up[1] * scale, origin_z + up[2] * scale); + // third vertex + gl.glTexCoord2f(0.0625f, 1.0625f); + gl.glVertex3f(origin_x + right[0] * scale, origin_y + right[1] * scale, origin_z + right[2] * scale); + } + gl.glEnd(); + + gl.glDisable(GL_BLEND); + gl.glColor4f(1, 1, 1, 1); + gl.glDepthMask(true); // back to normal Z buffering + GL_TexEnv(GL_REPLACE); + } + + /** + * R_DrawParticles + */ + void R_DrawParticles() { + + if (gl_ext_pointparameters.value != 0.0f && qglPointParameterfEXT) { + + //gl.gl.glEnableClientState(GL_VERTEX_ARRAY); + gl.glVertexPointer(3, 0, particle_t.vertexArray); + gl.glEnableClientState(GL_COLOR_ARRAY); + gl.glColorPointer(4, true, 0, particle_t.getColorAsByteBuffer()); + + gl.glDepthMask(false); + gl.glEnable(GL_BLEND); + gl.glDisable(GL_TEXTURE_2D); + gl.glPointSize(gl_particle_size.value); + + gl.glDrawArrays(GL_POINTS, 0, r_newrefdef.num_particles); + + gl.glDisableClientState(GL_COLOR_ARRAY); + //gl.gl.glDisableClientState(GL_VERTEX_ARRAY); + + gl.glDisable(GL_BLEND); + gl.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + gl.glDepthMask(true); + gl.glEnable(GL_TEXTURE_2D); + + } + else { + GL_DrawParticles(r_newrefdef.num_particles); + } + } + + /** + * R_PolyBlend + */ + void R_PolyBlend() { + if (gl_polyblend.value == 0.0f) + return; + + if (v_blend[3] == 0.0f) + return; + + gl.glDisable(GL_ALPHA_TEST); + gl.glEnable(GL_BLEND); + gl.glDisable(GL_DEPTH_TEST); + gl.glDisable(GL_TEXTURE_2D); + + gl.glLoadIdentity(); + + // FIXME: get rid of these + gl.glRotatef(-90, 1, 0, 0); // put Z going up + gl.glRotatef(90, 0, 0, 1); // put Z going up + + gl.glColor4f(v_blend[0], v_blend[1], v_blend[2], v_blend[3]); + + gl.glBegin(GL_QUADS); + + gl.glVertex3f(10, 100, 100); + gl.glVertex3f(10, -100, 100); + gl.glVertex3f(10, -100, -100); + gl.glVertex3f(10, 100, -100); + gl.glEnd(); + + gl.glDisable(GL_BLEND); + gl.glEnable(GL_TEXTURE_2D); + gl.glEnable(GL_ALPHA_TEST); + + gl.glColor4f(1, 1, 1, 1); + } + + // ======================================================================= + + /** + * SignbitsForPlane + */ + int SignbitsForPlane(cplane_t out) { + // for fast box on planeside test + int bits = 0; + for (int j = 0; j < 3; j++) { + if (out.normal[j] < 0) + bits |= (1 << j); + } + return bits; + } + + /** + * R_SetFrustum + */ + void R_SetFrustum() { + // rotate VPN right by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[0].normal, vup, vpn, - (90f - r_newrefdef.fov_x / 2f)); + // rotate VPN left by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[1].normal, vup, vpn, 90f - r_newrefdef.fov_x / 2f); + // rotate VPN up by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[2].normal, vright, vpn, 90f - r_newrefdef.fov_y / 2f); + // rotate VPN down by FOV_X/2 degrees + Math3D.RotatePointAroundVector(frustum[3].normal, vright, vpn, - (90f - r_newrefdef.fov_y / 2f)); + + for (int i = 0; i < 4; i++) { + frustum[i].type = Defines.PLANE_ANYZ; + frustum[i].dist = Math3D.DotProduct(r_origin, frustum[i].normal); + frustum[i].signbits = (byte) SignbitsForPlane(frustum[i]); + } + } + + // ======================================================================= + + // stack variable + private final float[] temp = {0, 0, 0}; + /** + * R_SetupFrame + */ + void R_SetupFrame() { + r_framecount++; + + // build the transformation matrix for the given view angles + Math3D.VectorCopy(r_newrefdef.vieworg, r_origin); + + Math3D.AngleVectors(r_newrefdef.viewangles, vpn, vright, vup); + + // current viewcluster + mleaf_t leaf; + if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) { + r_oldviewcluster = r_viewcluster; + r_oldviewcluster2 = r_viewcluster2; + leaf = Mod_PointInLeaf(r_origin, r_worldmodel); + r_viewcluster = r_viewcluster2 = leaf.cluster; + + // check above and below so crossing solid water doesn't draw wrong + if (leaf.contents == 0) { // look down a bit + Math3D.VectorCopy(r_origin, temp); + temp[2] -= 16; + leaf = Mod_PointInLeaf(temp, r_worldmodel); + if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2)) + r_viewcluster2 = leaf.cluster; + } + else { // look up a bit + Math3D.VectorCopy(r_origin, temp); + temp[2] += 16; + leaf = Mod_PointInLeaf(temp, r_worldmodel); + if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2)) + r_viewcluster2 = leaf.cluster; + } + } + + for (int i = 0; i < 4; i++) + v_blend[i] = r_newrefdef.blend[i]; + + c_brush_polys = 0; + c_alias_polys = 0; + + // clear out the portion of the screen that the NOWORLDMODEL defines + if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) { + gl.glEnable(GL_SCISSOR_TEST); + gl.glClearColor(0.3f, 0.3f, 0.3f, 1.0f); + gl.glScissor( + r_newrefdef.x, + vid.height - r_newrefdef.height - r_newrefdef.y, + r_newrefdef.width, + r_newrefdef.height); + gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + gl.glClearColor(1.0f, 0.0f, 0.5f, 0.5f); + gl.glDisable(GL_SCISSOR_TEST); + } + } + + /** + * MYgluPerspective + * + * @param fovy + * @param aspect + * @param zNear + * @param zFar + */ + void MYgluPerspective(double fovy, double aspect, double zNear, double zFar) { + double ymax = zNear * Math.tan(fovy * Math.PI / 360.0); + double ymin = -ymax; + + double xmin = ymin * aspect; + double xmax = ymax * aspect; + + xmin += - (2 * gl_state.camera_separation) / zNear; + xmax += - (2 * gl_state.camera_separation) / zNear; + + gl.glFrustum(xmin, xmax, ymin, ymax, zNear, zFar); + } + + /** + * R_SetupGL + */ + void R_SetupGL() { + + // + // set up viewport + // + //int x = (int) Math.floor(r_newrefdef.x * vid.width / vid.width); + int x = r_newrefdef.x; + //int x2 = (int) Math.ceil((r_newrefdef.x + r_newrefdef.width) * vid.width / vid.width); + int x2 = r_newrefdef.x + r_newrefdef.width; + //int y = (int) Math.floor(vid.height - r_newrefdef.y * vid.height / vid.height); + int y = vid.height - r_newrefdef.y; + //int y2 = (int) Math.ceil(vid.height - (r_newrefdef.y + r_newrefdef.height) * vid.height / vid.height); + int y2 = vid.height - (r_newrefdef.y + r_newrefdef.height); + + int w = x2 - x; + int h = y - y2; + + gl.glViewport(x, y2, w, h); + + // + // set up projection matrix + // + float screenaspect = (float) r_newrefdef.width / r_newrefdef.height; + gl.glMatrixMode(GL_PROJECTION); + gl.glLoadIdentity(); + MYgluPerspective(r_newrefdef.fov_y, screenaspect, 4, 4096); + + gl.glCullFace(GL_FRONT); + + gl.glMatrixMode(GL_MODELVIEW); + gl.glLoadIdentity(); + + gl.glRotatef(-90, 1, 0, 0); // put Z going up + gl.glRotatef(90, 0, 0, 1); // put Z going up + gl.glRotatef(-r_newrefdef.viewangles[2], 1, 0, 0); + gl.glRotatef(-r_newrefdef.viewangles[0], 0, 1, 0); + gl.glRotatef(-r_newrefdef.viewangles[1], 0, 0, 1); + gl.glTranslatef(-r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1], -r_newrefdef.vieworg[2]); + + gl.glGetFloat(GL_MODELVIEW_MATRIX, r_world_matrix); + r_world_matrix.clear(); + + // + // set drawing parms + // + if (gl_cull.value != 0.0f) + gl.glEnable(GL_CULL_FACE); + else + gl.glDisable(GL_CULL_FACE); + + gl.glDisable(GL_BLEND); + gl.glDisable(GL_ALPHA_TEST); + gl.glEnable(GL_DEPTH_TEST); + } + + int trickframe = 0; + + /** + * R_Clear + */ + void R_Clear() { + if (gl_ztrick.value != 0.0f) { + + if (gl_clear.value != 0.0f) { + gl.glClear(GL_COLOR_BUFFER_BIT); + } + + trickframe++; + if ((trickframe & 1) != 0) { + gldepthmin = 0; + gldepthmax = 0.49999f; + gl.glDepthFunc(GL_LEQUAL); + } + else { + gldepthmin = 1; + gldepthmax = 0.5f; + gl.glDepthFunc(GL_GEQUAL); + } + } + else { + if (gl_clear.value != 0.0f) + gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + else + gl.glClear(GL_DEPTH_BUFFER_BIT); + + gldepthmin = 0; + gldepthmax = 1; + gl.glDepthFunc(GL_LEQUAL); + } + gl.glDepthRange(gldepthmin, gldepthmax); + } + + /** + * R_Flash + */ + void R_Flash() { + R_PolyBlend(); + } + + /** + * R_RenderView + * r_newrefdef must be set before the first call + */ + void R_RenderView(refdef_t fd) { + + if (r_norefresh.value != 0.0f) + return; + + r_newrefdef = fd; + + // included by cwei + if (r_newrefdef == null) { + Com.Error(Defines.ERR_DROP, "R_RenderView: refdef_t fd is null"); + } + + if (r_worldmodel == null && (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) + Com.Error(Defines.ERR_DROP, "R_RenderView: NULL worldmodel"); + + if (r_speeds.value != 0.0f) { + c_brush_polys = 0; + c_alias_polys = 0; + } + + R_PushDlights(); + + if (gl_finish.value != 0.0f) + gl.glFinish(); + + R_SetupFrame(); + + R_SetFrustum(); + + R_SetupGL(); + + R_MarkLeaves(); // done here so we know if we're in water + + R_DrawWorld(); + + R_DrawEntitiesOnList(); + + R_RenderDlights(); + + R_DrawParticles(); + + R_DrawAlphaSurfaces(); + + R_Flash(); + + if (r_speeds.value != 0.0f) { + VID.Printf( + Defines.PRINT_ALL, + "%4i wpoly %4i epoly %i tex %i lmaps\n", + new Vargs(4).add(c_brush_polys).add(c_alias_polys).add(c_visible_textures).add(c_visible_lightmaps)); + } + } + + /** + * R_SetGL2D + */ + void R_SetGL2D() { + // set 2D virtual screen size + gl.glViewport(0, 0, vid.width, vid.height); + gl.glMatrixMode(GL_PROJECTION); + gl.glLoadIdentity(); + gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999); + gl.glMatrixMode(GL_MODELVIEW); + gl.glLoadIdentity(); + gl.glDisable(GL_DEPTH_TEST); + gl.glDisable(GL_CULL_FACE); + gl.glDisable(GL_BLEND); + gl.glEnable(GL_ALPHA_TEST); + gl.glColor4f(1, 1, 1, 1); + } + + // stack variable + private final float[] light = { 0, 0, 0 }; + /** + * R_SetLightLevel + */ + void R_SetLightLevel() { + if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) + return; + + // save off light value for server to look at (BIG HACK!) + + R_LightPoint(r_newrefdef.vieworg, light); + + // pick the greatest component, which should be the same + // as the mono value returned by software + if (light[0] > light[1]) { + if (light[0] > light[2]) + r_lightlevel.value = 150 * light[0]; + else + r_lightlevel.value = 150 * light[2]; + } + else { + if (light[1] > light[2]) + r_lightlevel.value = 150 * light[1]; + else + r_lightlevel.value = 150 * light[2]; + } + } + + /** + * R_RenderFrame + */ + public void R_RenderFrame(refdef_t fd) { + R_RenderView(fd); + R_SetLightLevel(); + R_SetGL2D(); + } + + /** + * R_Register + */ + protected void R_Register() { + r_lefthand = Cvar.Get("hand", "0", Defines.CVAR_USERINFO | Defines.CVAR_ARCHIVE); + r_norefresh = Cvar.Get("r_norefresh", "0", 0); + r_fullbright = Cvar.Get("r_fullbright", "0", 0); + r_drawentities = Cvar.Get("r_drawentities", "1", 0); + r_drawworld = Cvar.Get("r_drawworld", "1", 0); + r_novis = Cvar.Get("r_novis", "0", 0); + r_nocull = Cvar.Get("r_nocull", "0", 0); + r_lerpmodels = Cvar.Get("r_lerpmodels", "1", 0); + r_speeds = Cvar.Get("r_speeds", "0", 0); + + r_lightlevel = Cvar.Get("r_lightlevel", "1", 0); + + gl_nosubimage = Cvar.Get("gl_nosubimage", "0", 0); + gl_allow_software = Cvar.Get("gl_allow_software", "0", 0); + + gl_particle_min_size = Cvar.Get("gl_particle_min_size", "2", Defines.CVAR_ARCHIVE); + gl_particle_max_size = Cvar.Get("gl_particle_max_size", "40", Defines.CVAR_ARCHIVE); + gl_particle_size = Cvar.Get("gl_particle_size", "40", Defines.CVAR_ARCHIVE); + gl_particle_att_a = Cvar.Get("gl_particle_att_a", "0.01", Defines.CVAR_ARCHIVE); + gl_particle_att_b = Cvar.Get("gl_particle_att_b", "0.0", Defines.CVAR_ARCHIVE); + gl_particle_att_c = Cvar.Get("gl_particle_att_c", "0.01", Defines.CVAR_ARCHIVE); + + gl_modulate = Cvar.Get("gl_modulate", "1.5", Defines.CVAR_ARCHIVE); + gl_log = Cvar.Get("gl_log", "0", 0); + gl_bitdepth = Cvar.Get("gl_bitdepth", "0", 0); + gl_mode = Cvar.Get("gl_mode", "3", Defines.CVAR_ARCHIVE); // 640x480 + gl_lightmap = Cvar.Get("gl_lightmap", "0", 0); + gl_shadows = Cvar.Get("gl_shadows", "0", Defines.CVAR_ARCHIVE); + gl_dynamic = Cvar.Get("gl_dynamic", "1", 0); + gl_nobind = Cvar.Get("gl_nobind", "0", 0); + gl_round_down = Cvar.Get("gl_round_down", "1", 0); + gl_picmip = Cvar.Get("gl_picmip", "0", 0); + gl_skymip = Cvar.Get("gl_skymip", "0", 0); + gl_showtris = Cvar.Get("gl_showtris", "0", 0); + gl_ztrick = Cvar.Get("gl_ztrick", "0", 0); + gl_finish = Cvar.Get("gl_finish", "0", Defines.CVAR_ARCHIVE); + gl_clear = Cvar.Get("gl_clear", "0", 0); + gl_cull = Cvar.Get("gl_cull", "1", 0); + gl_polyblend = Cvar.Get("gl_polyblend", "1", 0); + gl_flashblend = Cvar.Get("gl_flashblend", "0", 0); + gl_playermip = Cvar.Get("gl_playermip", "0", 0); + gl_monolightmap = Cvar.Get("gl_monolightmap", "0", 0); + gl_driver = Cvar.Get("gl_driver", "opengl32", Defines.CVAR_ARCHIVE); + gl_texturemode = Cvar.Get("gl_texturemode", "GL_LINEAR_MIPMAP_NEAREST", Defines.CVAR_ARCHIVE); + gl_texturealphamode = Cvar.Get("gl_texturealphamode", "default", Defines.CVAR_ARCHIVE); + gl_texturesolidmode = Cvar.Get("gl_texturesolidmode", "default", Defines.CVAR_ARCHIVE); + gl_lockpvs = Cvar.Get("gl_lockpvs", "0", 0); + + gl_vertex_arrays = Cvar.Get("gl_vertex_arrays", "1", Defines.CVAR_ARCHIVE); + + gl_ext_swapinterval = Cvar.Get("gl_ext_swapinterval", "1", Defines.CVAR_ARCHIVE); + gl_ext_palettedtexture = Cvar.Get("gl_ext_palettedtexture", "0", Defines.CVAR_ARCHIVE); + gl_ext_multitexture = Cvar.Get("gl_ext_multitexture", "1", Defines.CVAR_ARCHIVE); + gl_ext_pointparameters = Cvar.Get("gl_ext_pointparameters", "1", Defines.CVAR_ARCHIVE); + gl_ext_compiled_vertex_array = Cvar.Get("gl_ext_compiled_vertex_array", "1", Defines.CVAR_ARCHIVE); + + gl_drawbuffer = Cvar.Get("gl_drawbuffer", "GL_BACK", 0); + gl_swapinterval = Cvar.Get("gl_swapinterval", "0", Defines.CVAR_ARCHIVE); + + gl_saturatelighting = Cvar.Get("gl_saturatelighting", "0", 0); + + gl_3dlabs_broken = Cvar.Get("gl_3dlabs_broken", "1", Defines.CVAR_ARCHIVE); + + vid_fullscreen = Cvar.Get("vid_fullscreen", "0", Defines.CVAR_ARCHIVE); + vid_gamma = Cvar.Get("vid_gamma", "1.0", Defines.CVAR_ARCHIVE); + vid_ref = Cvar.Get("vid_ref", "lwjgl", Defines.CVAR_ARCHIVE); + + Cmd.AddCommand("imagelist", new xcommand_t() { + public void execute() { + GL_ImageList_f(); + } + }); + + Cmd.AddCommand("screenshot", new xcommand_t() { + public void execute() { + GL_ScreenShot_f(); + } + }); + Cmd.AddCommand("modellist", new xcommand_t() { + public void execute() { + Mod_Modellist_f(); + } + }); + Cmd.AddCommand("gl_strings", new xcommand_t() { + public void execute() { + GL_Strings_f(); + } + }); + } + + /** + * R_SetMode + */ + protected boolean R_SetMode() { + boolean fullscreen = (vid_fullscreen.value > 0.0f); + + vid_fullscreen.modified = false; + gl_mode.modified = false; + + Dimension dim = new Dimension(vid.width, vid.height); + + int err; // enum rserr_t + if ((err = glImpl.setMode(dim, (int) gl_mode.value, fullscreen)) == rserr_ok) { + gl_state.prev_mode = (int) gl_mode.value; + } + else { + if (err == rserr_invalid_fullscreen) { + Cvar.SetValue("vid_fullscreen", 0); + vid_fullscreen.modified = false; + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - fullscreen unavailable in this mode\n"); + if ((err = glImpl.setMode(dim, (int) gl_mode.value, false)) == rserr_ok) + return true; + } + else if (err == rserr_invalid_mode) { + Cvar.SetValue("gl_mode", gl_state.prev_mode); + gl_mode.modified = false; + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - invalid mode\n"); + } + + // try setting it back to something safe + if ((err = glImpl.setMode(dim, gl_state.prev_mode, false)) != rserr_ok) { + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_SetMode() - could not revert to safe mode\n"); + return false; + } + } + return true; + } + + float[] r_turbsin = new float[256]; + + /** + * R_Init + */ + protected boolean R_Init() { + return R_Init(0, 0); + } + /** + * R_Init + */ + public boolean R_Init(int vid_xpos, int vid_ypos) { + + assert(Warp.SIN.length == 256) : "warpsin table bug"; + + // fill r_turbsin + for (int j = 0; j < 256; j++) { + r_turbsin[j] = Warp.SIN[j] * 0.5f; + } + + VID.Printf(Defines.PRINT_ALL, "ref_gl version: " + REF_VERSION + '\n'); + + Draw_GetPalette(); + + R_Register(); + + // set our "safe" modes + gl_state.prev_mode = 3; + + // create the window and set up the context + if (!R_SetMode()) { + VID.Printf(Defines.PRINT_ALL, "ref_gl::R_Init() - could not R_SetMode()\n"); + return false; + } + return true; + } + + /** + * R_Init2 + */ + public boolean R_Init2() { + VID.MenuInit(); + + /* + ** get our various GL strings + */ + gl_config.vendor_string = gl.glGetString(GL_VENDOR); + VID.Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n'); + gl_config.renderer_string = gl.glGetString(GL_RENDERER); + VID.Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n'); + gl_config.version_string = gl.glGetString(GL_VERSION); + VID.Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n'); + gl_config.extensions_string = gl.glGetString(GL_EXTENSIONS); + VID.Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n'); + + gl_config.parseOpenGLVersion(); + + String renderer_buffer = gl_config.renderer_string.toLowerCase(); + String vendor_buffer = gl_config.vendor_string.toLowerCase(); + + if (renderer_buffer.indexOf("voodoo") >= 0) { + if (renderer_buffer.indexOf("rush") < 0) + gl_config.renderer = GL_RENDERER_VOODOO; + else + gl_config.renderer = GL_RENDERER_VOODOO_RUSH; + } + else if (vendor_buffer.indexOf("sgi") >= 0) + gl_config.renderer = GL_RENDERER_SGI; + else if (renderer_buffer.indexOf("permedia") >= 0) + gl_config.renderer = GL_RENDERER_PERMEDIA2; + else if (renderer_buffer.indexOf("glint") >= 0) + gl_config.renderer = GL_RENDERER_GLINT_MX; + else if (renderer_buffer.indexOf("glzicd") >= 0) + gl_config.renderer = GL_RENDERER_REALIZM; + else if (renderer_buffer.indexOf("gdi") >= 0) + gl_config.renderer = GL_RENDERER_MCD; + else if (renderer_buffer.indexOf("pcx2") >= 0) + gl_config.renderer = GL_RENDERER_PCX2; + else if (renderer_buffer.indexOf("verite") >= 0) + gl_config.renderer = GL_RENDERER_RENDITION; + else + gl_config.renderer = GL_RENDERER_OTHER; + + String monolightmap = gl_monolightmap.string.toUpperCase(); + if (monolightmap.length() < 2 || monolightmap.charAt(1) != 'F') { + if (gl_config.renderer == GL_RENDERER_PERMEDIA2) { + Cvar.Set("gl_monolightmap", "A"); + VID.Printf(Defines.PRINT_ALL, "...using gl_monolightmap 'a'\n"); + } + else if ((gl_config.renderer & GL_RENDERER_POWERVR) != 0) { + Cvar.Set("gl_monolightmap", "0"); + } + else { + Cvar.Set("gl_monolightmap", "0"); + } + } + + // power vr can't have anything stay in the framebuffer, so + // the screen needs to redraw the tiled background every frame + if ((gl_config.renderer & GL_RENDERER_POWERVR) != 0) { + Cvar.Set("scr_drawall", "1"); + } + else { + Cvar.Set("scr_drawall", "0"); + } + + // MCD has buffering issues + if (gl_config.renderer == GL_RENDERER_MCD) { + Cvar.SetValue("gl_finish", 1); + } + + if ((gl_config.renderer & GL_RENDERER_3DLABS) != 0) { + if (gl_3dlabs_broken.value != 0.0f) + gl_config.allow_cds = false; + else + gl_config.allow_cds = true; + } + else { + gl_config.allow_cds = true; + } + + if (gl_config.allow_cds) + VID.Printf(Defines.PRINT_ALL, "...allowing CDS\n"); + else + VID.Printf(Defines.PRINT_ALL, "...disabling CDS\n"); + + /* + ** grab extensions + */ + if (gl_config.extensions_string.indexOf("GL_EXT_compiled_vertex_array") >= 0 + || gl_config.extensions_string.indexOf("GL_SGI_compiled_vertex_array") >= 0) { + VID.Printf(Defines.PRINT_ALL, "...enabling GL_EXT_compiled_vertex_array\n"); + // qgl.glLockArraysEXT = ( void * ) qwglGetProcAddress( "glLockArraysEXT" ); + if (gl_ext_compiled_vertex_array.value != 0.0f) + qglLockArraysEXT = true; + else + qglLockArraysEXT = false; + // qgl.glUnlockArraysEXT = ( void * ) qwglGetProcAddress( "glUnlockArraysEXT" ); + //qglUnlockArraysEXT = true; + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n"); + qglLockArraysEXT = false; + } + + if (gl_config.extensions_string.indexOf("WGL_EXT_swap_control") >= 0) { + qwglSwapIntervalEXT = true; + VID.Printf(Defines.PRINT_ALL, "...enabling WGL_EXT_swap_control\n"); + } else { + qwglSwapIntervalEXT = false; + VID.Printf(Defines.PRINT_ALL, "...WGL_EXT_swap_control not found\n"); + } + + if (gl_config.extensions_string.indexOf("GL_EXT_point_parameters") >= 0) { + if (gl_ext_pointparameters.value != 0.0f) { + // qgl.glPointParameterfEXT = ( void (APIENTRY *)( GLenum, GLfloat ) ) qwglGetProcAddress( "glPointParameterfEXT" ); + qglPointParameterfEXT = true; + // qgl.glPointParameterfvEXT = ( void (APIENTRY *)( GLenum, const GLfloat * ) ) qwglGetProcAddress( "glPointParameterfvEXT" ); + VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_point_parameters\n"); + } + else { + VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_point_parameters\n"); + } + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_EXT_point_parameters not found\n"); + } + + // #ifdef __linux__ + // if ( strstr( gl_config.extensions_string, "3DFX_set_global_palette" )) + // { + // if ( gl_ext_palettedtexture->value ) + // { + // VID.Printf( Defines.PRINT_ALL, "...using 3DFX_set_global_palette\n" ); + // qgl3DfxSetPaletteEXT = ( void ( APIENTRY * ) (GLuint *) )qwgl.glGetProcAddress( "gl3DfxSetPaletteEXT" ); + //// qglColorTableEXT = Fake_glColorTableEXT; + // } + // else + // { + // VID.Printf( Defines.PRINT_ALL, "...ignoring 3DFX_set_global_palette\n" ); + // } + // } + // else + // { + // VID.Printf( Defines.PRINT_ALL, "...3DFX_set_global_palette not found\n" ); + // } + // #endif + + if (!qglColorTableEXT + && gl_config.extensions_string.indexOf("GL_EXT_paletted_texture") >= 0 + && gl_config.extensions_string.indexOf("GL_EXT_shared_texture_palette") >= 0) { + if (gl_ext_palettedtexture.value != 0.0f) { + VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_shared_texture_palette\n"); + qglColorTableEXT = false; // true; TODO jogl bug + } + else { + VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_shared_texture_palette\n"); + qglColorTableEXT = false; + } + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_EXT_shared_texture_palette not found\n"); + } + + if (gl_config.extensions_string.indexOf("GL_ARB_multitexture") >= 0) { + VID.Printf(Defines.PRINT_ALL, "...using GL_ARB_multitexture\n"); + qglActiveTextureARB = true; + TEXTURE0 = GL_TEXTURE0_ARB; + TEXTURE1 = GL_TEXTURE1_ARB; + } + else { + VID.Printf(Defines.PRINT_ALL, "...GL_ARB_multitexture not found\n"); + } + + if (!(qglActiveTextureARB)) { + VID.Printf(Defines.PRINT_ALL, "Missing multi-texturing!\n"); + return false; + } + + GL_SetDefaultState(); + + GL_InitImages(); + Mod_Init(); + R_InitParticleTexture(); + Draw_InitLocal(); + + int err = gl.glGetError(); + if (err != GL_NO_ERROR) + VID.Printf( + Defines.PRINT_ALL, + "gl.glGetError() = 0x%x\n\t%s\n", + new Vargs(2).add(err).add("" + gl.glGetString(err))); + + glImpl.endFrame(); + return true; + } + + /** + * R_Shutdown + */ + public void R_Shutdown() { + Cmd.RemoveCommand("modellist"); + Cmd.RemoveCommand("screenshot"); + Cmd.RemoveCommand("imagelist"); + Cmd.RemoveCommand("gl_strings"); + + Mod_FreeAll(); + + GL_ShutdownImages(); + + /* + * shut down OS specific OpenGL stuff like contexts, etc. + */ + glImpl.shutdown(); + } + + /** + * R_BeginFrame + */ + public void R_BeginFrame(float camera_separation) { + + gl_state.camera_separation = camera_separation; + + /* + ** change modes if necessary + */ + if (gl_mode.modified || vid_fullscreen.modified) { + // FIXME: only restart if CDS is required + cvar_t ref; + + ref = Cvar.Get("vid_ref", "lwjgl", 0); + ref.modified = true; + } + + if (gl_log.modified) { + glImpl.enableLogging((gl_log.value != 0.0f)); + gl_log.modified = false; + } + + if (gl_log.value != 0.0f) { + glImpl.logNewFrame(); + } + + /* + ** update 3Dfx gamma -- it is expected that a user will do a vid_restart + ** after tweaking this value + */ + if (vid_gamma.modified) { + vid_gamma.modified = false; + + if ((gl_config.renderer & GL_RENDERER_VOODOO) != 0) { + // wird erstmal nicht gebraucht + + /* + char envbuffer[1024]; + float g; + + g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F; + Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g ); + putenv( envbuffer ); + Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g ); + putenv( envbuffer ); + */ + VID.Printf(Defines.PRINT_DEVELOPER, "gamma anpassung fuer VOODOO nicht gesetzt"); + } + } + + glImpl.beginFrame(camera_separation); + + /* + ** go into 2D mode + */ + gl.glViewport(0, 0, vid.width, vid.height); + gl.glMatrixMode(GL_PROJECTION); + gl.glLoadIdentity(); + gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999); + gl.glMatrixMode(GL_MODELVIEW); + gl.glLoadIdentity(); + gl.glDisable(GL_DEPTH_TEST); + gl.glDisable(GL_CULL_FACE); + gl.glDisable(GL_BLEND); + gl.glEnable(GL_ALPHA_TEST); + gl.glColor4f(1, 1, 1, 1); + + /* + ** draw buffer stuff + */ + if (gl_drawbuffer.modified) { + gl_drawbuffer.modified = false; + + if (gl_state.camera_separation == 0 || !gl_state.stereo_enabled) { + if (gl_drawbuffer.string.equalsIgnoreCase("GL_FRONT")) + gl.glDrawBuffer(GL_FRONT); + else + gl.glDrawBuffer(GL_BACK); + } + } + + /* + ** texturemode stuff + */ + if (gl_texturemode.modified) { + GL_TextureMode(gl_texturemode.string); + gl_texturemode.modified = false; + } + + if (gl_texturealphamode.modified) { + GL_TextureAlphaMode(gl_texturealphamode.string); + gl_texturealphamode.modified = false; + } + + if (gl_texturesolidmode.modified) { + GL_TextureSolidMode(gl_texturesolidmode.string); + gl_texturesolidmode.modified = false; + } + + /* + ** swapinterval stuff + */ + GL_UpdateSwapInterval(); + + // + // clear screen if desired + // + R_Clear(); + } + + int[] r_rawpalette = new int[256]; + + /** + * R_SetPalette + */ + public void R_SetPalette(byte[] palette) { + // 256 RGB values (768 bytes) + // or null + int i; + int color = 0; + + if (palette != null) { + int j =0; + for (i = 0; i < 256; i++) { + color = (palette[j++] & 0xFF) << 0; + color |= (palette[j++] & 0xFF) << 8; + color |= (palette[j++] & 0xFF) << 16; + color |= 0xFF000000; + r_rawpalette[i] = color; + } + } + else { + for (i = 0; i < 256; i++) { + r_rawpalette[i] = d_8to24table[i] | 0xff000000; + } + } + GL_SetTexturePalette(r_rawpalette); + + gl.glClearColor(0, 0, 0, 0); + gl.glClear(GL_COLOR_BUFFER_BIT); + gl.glClearColor(1f, 0f, 0.5f, 0.5f); + } + + static final int NUM_BEAM_SEGS = 6; + float[][] start_points = new float[NUM_BEAM_SEGS][3]; + // array of vec3_t + float[][] end_points = new float[NUM_BEAM_SEGS][3]; // array of vec3_t + + // stack variable + private final float[] perpvec = { 0, 0, 0 }; // vec3_t + private final float[] direction = { 0, 0, 0 }; // vec3_t + private final float[] normalized_direction = { 0, 0, 0 }; // vec3_t + private final float[] oldorigin = { 0, 0, 0 }; // vec3_t + private final float[] origin = { 0, 0, 0 }; // vec3_t + /** + * R_DrawBeam + */ + 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]); + } + + gl.glDisable(GL_TEXTURE_2D); + gl.glEnable(GL_BLEND); + gl.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; + + gl.glColor4f(r, g, b, e.alpha); + + gl.glBegin(GL_TRIANGLE_STRIP); + + float[] v; + + for (int i = 0; i < NUM_BEAM_SEGS; i++) { + v = start_points[i]; + gl.glVertex3f(v[0], v[1], v[2]); + v = end_points[i]; + gl.glVertex3f(v[0], v[1], v[2]); + v = start_points[(i + 1) % NUM_BEAM_SEGS]; + gl.glVertex3f(v[0], v[1], v[2]); + v = end_points[(i + 1) % NUM_BEAM_SEGS]; + gl.glVertex3f(v[0], v[1], v[2]); + } + gl.glEnd(); + + gl.glEnable(GL_TEXTURE_2D); + gl.glDisable(GL_BLEND); + gl.glDepthMask(true); + } +}
\ No newline at end of file diff --git a/src/jake2/render/fast/Mesh.java b/src/jake2/render/fast/Mesh.java new file mode 100644 index 0000000..2cd7d81 --- /dev/null +++ b/src/jake2/render/fast/Mesh.java @@ -0,0 +1,688 @@ +/* + * Mesh.java + * Copyright (C) 2003 + * + * $Id: Mesh.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.client.VID; +import jake2.client.entity_t; +import jake2.qcommon.qfiles; +import jake2.render.image_t; +import jake2.util.Lib; +import jake2.util.Math3D; + +import java.nio.FloatBuffer; +import java.nio.IntBuffer; + +/** + * Mesh + * + * @author cwei + */ +public abstract class Mesh extends Light { + + // g_mesh.c: triangle model functions + /* + ============================================================= + + ALIAS MODELS + + ============================================================= + */ + + static final int NUMVERTEXNORMALS = 162; + + float[][] r_avertexnormals = Anorms.VERTEXNORMALS; + float[] shadevector = {0, 0, 0}; + float[] shadelight = {0, 0, 0}; + + // precalculated dot products for quantized angles + static final int SHADEDOT_QUANT = 16; + + float[][] r_avertexnormal_dots = Anorms.VERTEXNORMAL_DOTS; + + float[] shadedots = r_avertexnormal_dots[0]; + + /** + * GL_LerpVerts + * @param nverts + * @param ov + * @param verts + * @param move + * @param frontv + * @param backv + */ + void GL_LerpVerts(int nverts, int[] ov, int[] v, float[] move, float[] frontv, float[] backv ) + { + FloatBuffer lerp = vertexArrayBuf; + lerp.limit((nverts << 2) - nverts); // nverts * 3 + + int ovv, vv; + //PMM -- added RF_SHELL_DOUBLE, RF_SHELL_HALF_DAM + if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0 ) + { + float[] normal; + int j = 0; + for (int i=0 ; i < nverts; i++/* , v++, ov++, lerp+=4 */) + { + vv = v[i]; + normal = r_avertexnormals[(vv >>> 24 ) & 0xFF]; + ovv = ov[i]; + lerp.put(j, move[0] + (ovv & 0xFF)* backv[0] + (vv & 0xFF) * frontv[0] + normal[0] * Defines.POWERSUIT_SCALE); + lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF) * backv[1] + ((vv >>> 8) & 0xFF) * frontv[1] + normal[1] * Defines.POWERSUIT_SCALE); + lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF) * backv[2] + ((vv >>> 16) & 0xFF) * frontv[2] + normal[2] * Defines.POWERSUIT_SCALE); + j += 3; + } + } + else + { + int j = 0; + for (int i=0 ; i < nverts; i++ /* , v++, ov++, lerp+=4 */) + { + ovv = ov[i]; + vv = v[i]; + + lerp.put(j, move[0] + (ovv & 0xFF)* backv[0] + (vv & 0xFF)*frontv[0]); + lerp.put(j + 1, move[1] + ((ovv >>> 8) & 0xFF)* backv[1] + ((vv >>> 8) & 0xFF)*frontv[1]); + lerp.put(j + 2, move[2] + ((ovv >>> 16) & 0xFF)* backv[2] + ((vv >>> 16) & 0xFF)*frontv[2]); + j += 3; + } + } + } + + FloatBuffer colorArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 4); + FloatBuffer vertexArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 3); + FloatBuffer textureArrayBuf = Lib.newFloatBuffer(qfiles.MAX_VERTS * 2); + boolean isFilled = false; + float[] tmpVec = {0, 0, 0}; + float[][] vectors = { + {0, 0, 0}, {0, 0, 0}, {0, 0, 0} // 3 mal vec3_t + }; + + // stack variable + private final float[] move = {0, 0, 0}; // vec3_t + private final float[] frontv = {0, 0, 0}; // vec3_t + private final float[] backv = {0, 0, 0}; // vec3_t + /** + * GL_DrawAliasFrameLerp + * + * interpolates between two frames and origins + * FIXME: batch lerp all vertexes + */ + void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, float backlerp) + { + qfiles.daliasframe_t frame = paliashdr.aliasFrames[currententity.frame]; + + int[] verts = frame.verts; + + qfiles.daliasframe_t oldframe = paliashdr.aliasFrames[currententity.oldframe]; + + int[] ov = oldframe.verts; + + float alpha; + if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0) + alpha = currententity.alpha; + else + alpha = 1.0f; + + // PMM - added double shell + if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) + gl.glDisable( GL_TEXTURE_2D ); + + float frontlerp = 1.0f - backlerp; + + // move should be the delta back to the previous frame * backlerp + Math3D.VectorSubtract (currententity.oldorigin, currententity.origin, frontv); + Math3D.AngleVectors (currententity.angles, vectors[0], vectors[1], vectors[2]); + + move[0] = Math3D.DotProduct (frontv, vectors[0]); // forward + move[1] = -Math3D.DotProduct (frontv, vectors[1]); // left + move[2] = Math3D.DotProduct (frontv, vectors[2]); // up + + Math3D.VectorAdd (move, oldframe.translate, move); + + for (int i=0 ; i<3 ; i++) + { + move[i] = backlerp*move[i] + frontlerp*frame.translate[i]; + frontv[i] = frontlerp*frame.scale[i]; + backv[i] = backlerp*oldframe.scale[i]; + } + + // ab hier wird optimiert + + GL_LerpVerts( paliashdr.num_xyz, ov, verts, move, frontv, backv ); + + //gl.gl.glEnableClientState( GL_VERTEX_ARRAY ); + gl.glVertexPointer( 3, 0, vertexArrayBuf ); + + // PMM - added double damage shell + if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0) + { + gl.glColor4f( shadelight[0], shadelight[1], shadelight[2], alpha ); + } + else + { + gl.glEnableClientState( GL_COLOR_ARRAY ); + gl.glColorPointer( 4, 0, colorArrayBuf ); + + // + // pre light everything + // + FloatBuffer color = colorArrayBuf; + float l; + int size = paliashdr.num_xyz; + int j = 0; + for (int i = 0; i < size; i++ ) + { + l = shadedots[(verts[i] >>> 24) & 0xFF]; + color.put(j, l * shadelight[0]); + color.put(j + 1, l * shadelight[1]); + color.put(j + 2, l * shadelight[2]); + color.put(j + 3, alpha); + j += 4; + } + } + + gl.glClientActiveTextureARB(TEXTURE0); + gl.glTexCoordPointer( 2, 0, textureArrayBuf); + //gl.gl.glEnableClientState( GL_TEXTURE_COORD_ARRAY); + + int pos = 0; + int[] counts = paliashdr.counts; + + IntBuffer srcIndexBuf = null; + + FloatBuffer dstTextureCoords = textureArrayBuf; + FloatBuffer srcTextureCoords = paliashdr.textureCoordBuf; + + int dstIndex = 0; + int srcIndex = 0; + int count; + int mode; + int size = counts.length; + for (int j = 0; j < size; j++) { + + // get the vertex count and primitive type + count = counts[j]; + if (count == 0) + break; // done + + srcIndexBuf = paliashdr.indexElements[j]; + + mode = GL_TRIANGLE_STRIP; + if (count < 0) { + mode = GL_TRIANGLE_FAN; + count = -count; + } + srcIndex = pos << 1; + srcIndex--; + for (int k = 0; k < count; k++) { + dstIndex = srcIndexBuf.get(k) << 1; + dstTextureCoords.put(dstIndex, srcTextureCoords.get(++srcIndex)); + dstTextureCoords.put(++dstIndex, srcTextureCoords.get(++srcIndex)); + } + + gl.glDrawElements(mode, srcIndexBuf); + pos += count; + } + + // PMM - added double damage shell + if ( (currententity.flags & ( Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0 ) + gl.glEnable( GL_TEXTURE_2D ); + + gl.glDisableClientState( GL_COLOR_ARRAY ); + } + + private final float[] point = {0, 0, 0}; + /** + * GL_DrawAliasShadow + */ + 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; + gl.glBegin (GL_TRIANGLE_FAN); + } + else + gl.glBegin (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; + gl.glVertex3f(point[0], point[1], point[2]); + + orderIndex += 3; + + } while (--count != 0); + + gl.glEnd (); + } + } + +// TODO sync with jogl renderer. hoz + // stack variable + private final float[] mins = { 0, 0, 0 }; + private final float[] maxs = { 0, 0, 0 }; + /** + * R_CullAliasModel + */ + boolean R_CullAliasModel(entity_t e) { + qfiles.dmdl_t paliashdr = (qfiles.dmdl_t) currentmodel.extradata; + + if ((e.frame >= paliashdr.num_frames) || (e.frame < 0)) { + VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such frame " + e.frame + '\n'); + e.frame = 0; + } + if ((e.oldframe >= paliashdr.num_frames) || (e.oldframe < 0)) { + VID.Printf(Defines.PRINT_ALL, "R_CullAliasModel " + currentmodel.name + ": no such oldframe " + e.oldframe + '\n'); + e.oldframe = 0; + } + + qfiles.daliasframe_t pframe = paliashdr.aliasFrames[e.frame]; + qfiles.daliasframe_t poldframe = paliashdr.aliasFrames[e.oldframe]; + + /* + ** compute axially aligned mins and maxs + */ + if (pframe == poldframe) { + for (int i = 0; i < 3; i++) { + mins[i] = pframe.translate[i]; + maxs[i] = mins[i] + pframe.scale[i] * 255; + } + } else { + float thismaxs, oldmaxs; + for (int i = 0; i < 3; i++) { + thismaxs = pframe.translate[i] + pframe.scale[i] * 255; + + oldmaxs = poldframe.translate[i] + poldframe.scale[i] * 255; + + if (pframe.translate[i] < poldframe.translate[i]) + mins[i] = pframe.translate[i]; + else + mins[i] = poldframe.translate[i]; + + if (thismaxs > oldmaxs) + maxs[i] = thismaxs; + else + maxs[i] = oldmaxs; + } + } + + /* + ** compute a full bounding box + */ + float[] tmp; + for (int i = 0; i < 8; i++) { + tmp = bbox[i]; + if ((i & 1) != 0) + tmp[0] = mins[0]; + else + tmp[0] = maxs[0]; + + if ((i & 2) != 0) + tmp[1] = mins[1]; + else + tmp[1] = maxs[1]; + + if ((i & 4) != 0) + tmp[2] = mins[2]; + else + tmp[2] = maxs[2]; + } + + /* + ** rotate the bounding box + */ + tmp = mins; + Math3D.VectorCopy(e.angles, tmp); + tmp[YAW] = -tmp[YAW]; + Math3D.AngleVectors(tmp, vectors[0], vectors[1], vectors[2]); + + for (int i = 0; i < 8; i++) { + Math3D.VectorCopy(bbox[i], tmp); + + bbox[i][0] = Math3D.DotProduct(vectors[0], tmp); + bbox[i][1] = -Math3D.DotProduct(vectors[1], tmp); + bbox[i][2] = Math3D.DotProduct(vectors[2], tmp); + + Math3D.VectorAdd(e.origin, bbox[i], bbox[i]); + } + + int f, mask; + int aggregatemask = ~0; // 0xFFFFFFFF + + for (int p = 0; p < 8; p++) { + mask = 0; + + for (f = 0; f < 4; f++) { + float dp = Math3D.DotProduct(frustum[f].normal, bbox[p]); + + if ((dp - frustum[f].dist) < 0) { + mask |= (1 << f); + } + } + + aggregatemask &= mask; + } + + if (aggregatemask != 0) { + return true; + } + + return false; + } + + + // bounding box + float[][] bbox = { + {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, + {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0} + }; + +// TODO sync with jogl renderer. hoz + /** + * R_DrawAliasModel + */ + void R_DrawAliasModel(entity_t e) + { + if ( ( e.flags & Defines.RF_WEAPONMODEL ) == 0) + { + if ( R_CullAliasModel(e) ) + return; + } + + if ( (e.flags & Defines.RF_WEAPONMODEL) != 0 ) + { + if ( r_lefthand.value == 2.0f ) + return; + } + + qfiles.dmdl_t paliashdr = (qfiles.dmdl_t)currentmodel.extradata; + + // + // get lighting information + // + // PMM - rewrote, reordered to handle new shells & mixing + // PMM - 3.20 code .. replaced with original way of doing it to keep mod authors happy + // + int i; + if ( (currententity.flags & ( Defines.RF_SHELL_HALF_DAM | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_RED | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE )) != 0 ) + { + Math3D.VectorClear(shadelight); + if ((currententity.flags & Defines.RF_SHELL_HALF_DAM) != 0) + { + shadelight[0] = 0.56f; + shadelight[1] = 0.59f; + shadelight[2] = 0.45f; + } + if ( (currententity.flags & Defines.RF_SHELL_DOUBLE) != 0 ) + { + shadelight[0] = 0.9f; + shadelight[1] = 0.7f; + } + if ( (currententity.flags & Defines.RF_SHELL_RED) != 0 ) + shadelight[0] = 1.0f; + if ( (currententity.flags & Defines.RF_SHELL_GREEN) != 0 ) + shadelight[1] = 1.0f; + if ( (currententity.flags & Defines.RF_SHELL_BLUE) != 0 ) + shadelight[2] = 1.0f; + } + + else if ( (currententity.flags & Defines.RF_FULLBRIGHT) != 0 ) + { + for (i=0 ; i<3 ; i++) + shadelight[i] = 1.0f; + } + else + { + R_LightPoint (currententity.origin, shadelight); + + // player lighting hack for communication back to server + // big hack! + if ( (currententity.flags & Defines.RF_WEAPONMODEL) != 0 ) + { + // pick the greatest component, which should be the same + // as the mono value returned by software + if (shadelight[0] > shadelight[1]) + { + if (shadelight[0] > shadelight[2]) + r_lightlevel.value = 150*shadelight[0]; + else + r_lightlevel.value = 150*shadelight[2]; + } + else + { + if (shadelight[1] > shadelight[2]) + r_lightlevel.value = 150*shadelight[1]; + else + r_lightlevel.value = 150*shadelight[2]; + } + } + + if ( gl_monolightmap.string.charAt(0) != '0' ) + { + float s = shadelight[0]; + + if ( s < shadelight[1] ) + s = shadelight[1]; + if ( s < shadelight[2] ) + s = shadelight[2]; + + shadelight[0] = s; + shadelight[1] = s; + shadelight[2] = s; + } + } + + if ( (currententity.flags & Defines.RF_MINLIGHT) != 0 ) + { + for (i=0 ; i<3 ; i++) + if (shadelight[i] > 0.1f) + break; + if (i == 3) + { + shadelight[0] = 0.1f; + shadelight[1] = 0.1f; + shadelight[2] = 0.1f; + } + } + + if ( (currententity.flags & Defines.RF_GLOW) != 0 ) + { // bonus items will pulse with time + float scale; + float min; + + scale = (float)(0.1f * Math.sin(r_newrefdef.time*7)); + for (i=0 ; i<3 ; i++) + { + min = shadelight[i] * 0.8f; + shadelight[i] += scale; + if (shadelight[i] < min) + shadelight[i] = min; + } + } + + // ================= + // PGM ir goggles color override + if ( (r_newrefdef.rdflags & Defines.RDF_IRGOGGLES) != 0 && (currententity.flags & Defines.RF_IR_VISIBLE) != 0) + { + shadelight[0] = 1.0f; + shadelight[1] = 0.0f; + shadelight[2] = 0.0f; + } + // PGM + // ================= + + shadedots = r_avertexnormal_dots[((int)(currententity.angles[1] * (SHADEDOT_QUANT / 360.0))) & (SHADEDOT_QUANT - 1)]; + + float an = (float)(currententity.angles[1]/180*Math.PI); + shadevector[0] = (float)Math.cos(-an); + shadevector[1] = (float)Math.sin(-an); + shadevector[2] = 1; + Math3D.VectorNormalize(shadevector); + + // + // locate the proper data + // + + c_alias_polys += paliashdr.num_tris; + + // + // draw all the triangles + // + if ( (currententity.flags & Defines.RF_DEPTHHACK) != 0) // hack the depth range to prevent view model from poking into walls + gl.glDepthRange(gldepthmin, gldepthmin + 0.3*(gldepthmax-gldepthmin)); + + if ( (currententity.flags & Defines.RF_WEAPONMODEL) != 0 && (r_lefthand.value == 1.0f) ) + { + gl.glMatrixMode( GL_PROJECTION ); + gl.glPushMatrix(); + gl.glLoadIdentity(); + gl.glScalef( -1, 1, 1 ); + MYgluPerspective( r_newrefdef.fov_y, ( float ) r_newrefdef.width / r_newrefdef.height, 4, 4096); + gl.glMatrixMode( GL_MODELVIEW ); + + gl.glCullFace( GL_BACK ); + } + + gl.glPushMatrix (); + e.angles[PITCH] = -e.angles[PITCH]; // sigh. + R_RotateForEntity (e); + e.angles[PITCH] = -e.angles[PITCH]; // sigh. + + + + image_t skin; + // select skin + if (currententity.skin != null) + skin = currententity.skin; // custom player skin + else + { + if (currententity.skinnum >= qfiles.MAX_MD2SKINS) + skin = currentmodel.skins[0]; + else + { + skin = currentmodel.skins[currententity.skinnum]; + if (skin == null) + skin = currentmodel.skins[0]; + } + } + if (skin == null) + skin = r_notexture; // fallback... + GL_Bind(skin.texnum); + + // draw it + + gl.glShadeModel (GL_SMOOTH); + + GL_TexEnv( GL_MODULATE ); + if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 ) + { + gl.glEnable (GL_BLEND); + } + + + if ( (currententity.frame >= paliashdr.num_frames) + || (currententity.frame < 0) ) + { + VID.Printf (Defines.PRINT_ALL, "R_DrawAliasModel " + currentmodel.name +": no such frame " + currententity.frame + '\n'); + currententity.frame = 0; + currententity.oldframe = 0; + } + + if ( (currententity.oldframe >= paliashdr.num_frames) + || (currententity.oldframe < 0)) + { + VID.Printf (Defines.PRINT_ALL, "R_DrawAliasModel " + currentmodel.name +": no such oldframe " + currententity.oldframe + '\n'); + currententity.frame = 0; + currententity.oldframe = 0; + } + + if ( r_lerpmodels.value == 0.0f) + currententity.backlerp = 0; + + GL_DrawAliasFrameLerp(paliashdr, currententity.backlerp); + + GL_TexEnv( GL_REPLACE ); + gl.glShadeModel (GL_FLAT); + + gl.glPopMatrix (); + + if ( ( currententity.flags & Defines.RF_WEAPONMODEL ) != 0 && ( r_lefthand.value == 1.0F ) ) + { + gl.glMatrixMode( GL_PROJECTION ); + gl.glPopMatrix(); + gl.glMatrixMode( GL_MODELVIEW ); + gl.glCullFace( GL_FRONT ); + } + + if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 ) + { + gl.glDisable (GL_BLEND); + } + + if ( (currententity.flags & Defines.RF_DEPTHHACK) != 0) + gl.glDepthRange (gldepthmin, gldepthmax); + + if ( gl_shadows.value != 0.0f && (currententity.flags & (Defines.RF_TRANSLUCENT | Defines.RF_WEAPONMODEL)) == 0) + { + gl.glPushMatrix (); + R_RotateForEntity (e); + gl.glDisable (GL_TEXTURE_2D); + gl.glEnable (GL_BLEND); + gl.glColor4f (0,0,0,0.5f); + GL_DrawAliasShadow (paliashdr, currententity.frame ); + gl.glEnable (GL_TEXTURE_2D); + gl.glDisable (GL_BLEND); + gl.glPopMatrix (); + } + gl.glColor4f (1,1,1,1); + } +}
\ No newline at end of file diff --git a/src/jake2/render/fast/Misc.java b/src/jake2/render/fast/Misc.java new file mode 100644 index 0000000..d4df9af --- /dev/null +++ b/src/jake2/render/fast/Misc.java @@ -0,0 +1,282 @@ +/* + * Misc.java + * Copyright (C) 2003 + * + * $Id: Misc.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.client.VID; +import jake2.qcommon.FS; +import jake2.util.Lib; + +import java.io.*; +import java.nio.FloatBuffer; +import java.nio.MappedByteBuffer; +import java.nio.channels.FileChannel; + +/** + * Misc + * + * @author cwei + */ +public final class Misc extends Mesh { + + /* + ================== + R_InitParticleTexture + ================== + */ + byte[][] dottexture = + { + {0,0,0,0,0,0,0,0}, + {0,0,1,1,0,0,0,0}, + {0,1,1,1,1,0,0,0}, + {0,1,1,1,1,0,0,0}, + {0,0,1,1,0,0,0,0}, + {0,0,0,0,0,0,0,0}, + {0,0,0,0,0,0,0,0}, + {0,0,0,0,0,0,0,0}, + }; + + void R_InitParticleTexture() + { + int x,y; + byte[] data = new byte[8 * 8 * 4]; + + // + // particle texture + // + for (x=0 ; x<8 ; x++) + { + for (y=0 ; y<8 ; y++) + { + data[y * 32 + x * 4 + 0] = (byte)255; + data[y * 32 + x * 4 + 1] = (byte)255; + data[y * 32 + x * 4 + 2] = (byte)255; + data[y * 32 + x * 4 + 3] = (byte)(dottexture[x][y]*255); + + } + } + r_particletexture = GL_LoadPic("***particle***", data, 8, 8, it_sprite, 32); + + // + // also use this for bad textures, but without alpha + // + for (x=0 ; x<8 ; x++) + { + for (y=0 ; y<8 ; y++) + { + data[y * 32 + x * 4 + 0] = (byte)(dottexture[x&3][y&3]*255); + data[y * 32 + x * 4 + 1] = 0; // dottexture[x&3][y&3]*255; + data[y * 32 + x * 4 + 2] = 0; //dottexture[x&3][y&3]*255; + data[y * 32 + x * 4 + 3] = (byte)255; + } + } + r_notexture = GL_LoadPic("***r_notexture***", data, 8, 8, it_wall, 32); + } + +// /* +// ============================================================================== +// +// SCREEN SHOTS +// +// ============================================================================== +// */ +// +// typedef struct _TargaHeader { +// unsigned char id_length, colormap_type, image_type; +// unsigned short colormap_index, colormap_length; +// unsigned char colormap_size; +// unsigned short x_origin, y_origin, width, height; +// unsigned char pixel_size, attributes; +// } TargaHeader; + + private final static int TGA_HEADER_SIZE = 18; + + /* + ================== + GL_ScreenShot_f + ================== + */ + void GL_ScreenShot_f() { + StringBuffer sb = new StringBuffer(FS.Gamedir() + "/scrshot/jake00.tga"); + FS.CreatePath(sb.toString()); + File file = new File(sb.toString()); + // find a valid file name + int i = 0; int offset = sb.length() - 6; + while (file.exists() && i++ < 100) { + sb.setCharAt(offset, (char) ((i/10) + '0')); + sb.setCharAt(offset + 1, (char) ((i%10) + '0')); + file = new File(sb.toString()); + } + if (i == 100) { + VID.Printf(Defines.PRINT_ALL, "Clean up your screenshots\n"); + return; + } + + try { + RandomAccessFile out = new RandomAccessFile(file, "rw"); + FileChannel ch = out.getChannel(); + int fileLength = TGA_HEADER_SIZE + vid.width * vid.height * 3; + out.setLength(fileLength); + MappedByteBuffer image = ch.map(FileChannel.MapMode.READ_WRITE, 0, + fileLength); + + // write the TGA header + image.put(0, (byte) 0).put(1, (byte) 0); + image.put(2, (byte) 2); // uncompressed type + image.put(12, (byte) (vid.width & 0xFF)); // vid.width + image.put(13, (byte) (vid.width >> 8)); // vid.width + image.put(14, (byte) (vid.height & 0xFF)); // vid.height + image.put(15, (byte) (vid.height >> 8)); // vid.height + image.put(16, (byte) 24); // pixel size + + // go to image data position + image.position(TGA_HEADER_SIZE); + + + // change pixel alignment for reading + if (vid.width % 4 != 0) { + gl.glPixelStorei(GL_PACK_ALIGNMENT, 1); + } + + // OpenGL 1.2+ supports the GL_BGR color format + // check the GL_VERSION to use the TARGA BGR order if possible + // e.g.: 1.5.2 NVIDIA 66.29 + if (gl_config.getOpenGLVersion() >= 1.2f) { + // read the BGR values into the image buffer + gl.glReadPixels(0, 0, vid.width, vid.height, GL_BGR, GL_UNSIGNED_BYTE, image); + } else { + // read the RGB values into the image buffer + gl.glReadPixels(0, 0, vid.width, vid.height, GL_RGB, GL_UNSIGNED_BYTE, image); + // flip RGB to BGR + byte tmp; + for (i = TGA_HEADER_SIZE; i < fileLength; i += 3) { + tmp = image.get(i); + image.put(i, image.get(i + 2)); + image.put(i + 2, tmp); + } + } + // reset to default alignment + gl.glPixelStorei(GL_PACK_ALIGNMENT, 4); + // close the file channel + ch.close(); + } catch (IOException e) { + VID.Printf(Defines.PRINT_ALL, e.getMessage() + '\n'); + } + + VID.Printf(Defines.PRINT_ALL, "Wrote " + file + '\n'); + } + + /* + ** GL_Strings_f + */ + void GL_Strings_f() { + VID.Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n'); + VID.Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n'); + VID.Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n'); + VID.Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n'); + } + + /* + ** GL_SetDefaultState + */ + void GL_SetDefaultState() + { + gl.glClearColor(1f,0f, 0.5f , 0.5f); // original quake2 + //gl.gl.glClearColor(0, 0, 0, 0); // replaced with black + gl.glCullFace(GL_FRONT); + gl.glEnable(GL_TEXTURE_2D); + + gl.glEnable(GL_ALPHA_TEST); + gl.glAlphaFunc(GL_GREATER, 0.666f); + + gl.glDisable (GL_DEPTH_TEST); + gl.glDisable (GL_CULL_FACE); + gl.glDisable (GL_BLEND); + + gl.glColor4f (1,1,1,1); + + gl.glPolygonMode (GL_FRONT_AND_BACK, GL_FILL); + gl.glShadeModel (GL_FLAT); + + GL_TextureMode( gl_texturemode.string ); + GL_TextureAlphaMode( gl_texturealphamode.string ); + GL_TextureSolidMode( gl_texturesolidmode.string ); + + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + gl.glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + GL_TexEnv( GL_REPLACE ); + + if ( qglPointParameterfEXT ) + { + // float[] attenuations = { gl_particle_att_a.value, gl_particle_att_b.value, gl_particle_att_c.value }; + FloatBuffer att_buffer=Lib.newFloatBuffer(4); + att_buffer.put(0,gl_particle_att_a.value); + att_buffer.put(1,gl_particle_att_b.value); + att_buffer.put(2,gl_particle_att_c.value); + + gl.glEnable( GL_POINT_SMOOTH ); + gl.glPointParameterfEXT(GL_POINT_SIZE_MIN_EXT, gl_particle_min_size.value ); + gl.glPointParameterfEXT(GL_POINT_SIZE_MAX_EXT, gl_particle_max_size.value ); + gl.glPointParameterEXT(GL_DISTANCE_ATTENUATION_EXT, att_buffer ); + } + + if ( qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f ) + { + gl.glEnable(GL_SHARED_TEXTURE_PALETTE_EXT ); + + GL_SetTexturePalette( d_8to24table ); + } + + GL_UpdateSwapInterval(); + + /* + * vertex array extension + */ + gl.glEnableClientState(GL_VERTEX_ARRAY); + gl.glClientActiveTextureARB(TEXTURE0); + gl.glEnableClientState(GL_TEXTURE_COORD_ARRAY); + } + + void GL_UpdateSwapInterval() + { + if ( gl_swapinterval.modified ) + { + gl_swapinterval.modified = false; + if ( !gl_state.stereo_enabled ) + { + if (qwglSwapIntervalEXT) { + // ((WGL)gl).wgl.glSwapIntervalEXT((int)gl_swapinterval.value); + } + } + } + } +} diff --git a/src/jake2/render/fast/Model.java b/src/jake2/render/fast/Model.java new file mode 100644 index 0000000..47541d9 --- /dev/null +++ b/src/jake2/render/fast/Model.java @@ -0,0 +1,1358 @@ +/* + * Model.java + * Copyright (C) 2003 + * + * $Id: Model.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.client.VID; +import jake2.game.cplane_t; +import jake2.game.cvar_t; +import jake2.qcommon.*; +import jake2.render.*; +import jake2.util.*; + +import java.nio.*; +import java.util.Arrays; +import java.util.Vector; + +/** + * Model + * + * @author cwei + */ +public abstract class Model extends Surf { + + // models.c -- model loading and caching + + model_t loadmodel; + int modfilelen; + + byte[] mod_novis = new byte[Defines.MAX_MAP_LEAFS/8]; + + static final int MAX_MOD_KNOWN = 512; + model_t[] mod_known = new model_t[MAX_MOD_KNOWN]; + int mod_numknown; + + // the inline * models from the current map are kept seperate + model_t[] mod_inline = new model_t[MAX_MOD_KNOWN]; + + abstract void GL_SubdivideSurface(msurface_t surface); // Warp.java + + /* + =============== + Mod_PointInLeaf + =============== + */ + mleaf_t Mod_PointInLeaf(float[] p, model_t model) + { + mnode_t node; + float d; + cplane_t plane; + + if (model == null || model.nodes == null) + Com.Error (Defines.ERR_DROP, "Mod_PointInLeaf: bad model"); + + node = model.nodes[0]; // root node + while (true) + { + if (node.contents != -1) + return (mleaf_t)node; + + plane = node.plane; + d = Math3D.DotProduct(p, plane.normal) - plane.dist; + if (d > 0) + node = node.children[0]; + else + node = node.children[1]; + } + // never reached + } + + + byte[] decompressed = new byte[Defines.MAX_MAP_LEAFS / 8]; + byte[] model_visibility = new byte[Defines.MAX_MAP_VISIBILITY]; + + /* + =================== + Mod_DecompressVis + =================== + */ + byte[] Mod_DecompressVis(byte[] in, int offset, model_t model) + { + int c; + byte[] out; + int outp, inp; + int row; + + row = (model.vis.numclusters+7)>>3; + out = decompressed; + outp = 0; + inp = offset; + + if (in == null) + { // no vis info, so make all visible + while (row != 0) + { + out[outp++] = (byte)0xFF; + row--; + } + return decompressed; + } + + do + { + if (in[inp] != 0) + { + out[outp++] = in[inp++]; + continue; + } + + c = in[inp + 1] & 0xFF; + inp += 2; + while (c != 0) + { + out[outp++] = 0; + c--; + } + } while (outp < row); + + return decompressed; + } + + /* + ============== + Mod_ClusterPVS + ============== + */ + byte[] Mod_ClusterPVS(int cluster, model_t model) + { + if (cluster == -1 || model.vis == null) + return mod_novis; + //return Mod_DecompressVis( (byte *)model.vis + model.vis.bitofs[cluster][Defines.DVIS_PVS], model); + return Mod_DecompressVis(model_visibility, model.vis.bitofs[cluster][Defines.DVIS_PVS], model); + } + + +// =============================================================================== + + /* + ================ + Mod_Modellist_f + ================ + */ + void Mod_Modellist_f() + { + int i; + model_t mod; + int total; + + total = 0; + VID.Printf(Defines.PRINT_ALL,"Loaded models:\n"); + for (i=0; i < mod_numknown ; i++) + { + mod = mod_known[i]; + if (mod.name.length() == 0) + continue; + + VID.Printf (Defines.PRINT_ALL, "%8i : %s\n", new Vargs(2).add(mod.extradatasize).add(mod.name)); + total += mod.extradatasize; + } + VID.Printf (Defines.PRINT_ALL, "Total resident: " + total +'\n'); + } + + /* + =============== + Mod_Init + =============== + */ + void Mod_Init() + { + // init mod_known + for (int i=0; i < MAX_MOD_KNOWN; i++) { + mod_known[i] = new model_t(); + } + Arrays.fill(mod_novis, (byte)0xff); + } + + byte[] fileBuffer; + + /* + ================== + Mod_ForName + + Loads in a model for the given name + ================== + */ + model_t Mod_ForName(String name, boolean crash) + { + model_t mod = null; + int i; + + if (name == null || name.length() == 0) + Com.Error(Defines.ERR_DROP, "Mod_ForName: NULL name"); + + // + // inline models are grabbed only from worldmodel + // + if (name.charAt(0) == '*') + { + i = Integer.parseInt(name.substring(1)); + if (i < 1 || r_worldmodel == null || i >= r_worldmodel.numsubmodels) + Com.Error (Defines.ERR_DROP, "bad inline model number"); + return mod_inline[i]; + } + + // + // search the currently loaded models + // + for (i=0; i<mod_numknown ; i++) + { + mod = mod_known[i]; + + if (mod.name.length() == 0) + continue; + if (mod.name.equals(name) ) + return mod; + } + + // + // find a free model slot spot + // + for (i=0; i<mod_numknown ; i++) + { + mod = mod_known[i]; + + if (mod.name.length() == 0) + break; // free spot + } + if (i == mod_numknown) + { + if (mod_numknown == MAX_MOD_KNOWN) + Com.Error (Defines.ERR_DROP, "mod_numknown == MAX_MOD_KNOWN"); + mod_numknown++; + mod = mod_known[i]; + } + + mod.name = name; + + // + // load the file + // + fileBuffer = FS.LoadFile(name); + + if (fileBuffer == null) + { + if (crash) + Com.Error(Defines.ERR_DROP, "Mod_NumForName: " + mod.name + " not found"); + + mod.name = ""; + return null; + } + + modfilelen = fileBuffer.length; + + loadmodel = mod; + + // + // fill it in + // + ByteBuffer bb = ByteBuffer.wrap(fileBuffer); + bb.order(ByteOrder.LITTLE_ENDIAN); + + // call the apropriate loader + + bb.mark(); + int ident = bb.getInt(); + + bb.reset(); + + switch (ident) + { + case qfiles.IDALIASHEADER: + Mod_LoadAliasModel(mod, bb); + break; + case qfiles.IDSPRITEHEADER: + Mod_LoadSpriteModel(mod, bb); + break; + case qfiles.IDBSPHEADER: + Mod_LoadBrushModel(mod, bb); + break; + default: + Com.Error(Defines.ERR_DROP,"Mod_NumForName: unknown fileid for " + mod.name); + break; + } + + this.fileBuffer = null; // free it for garbage collection + return mod; + } + + /* + =============================================================================== + + BRUSHMODEL LOADING + + =============================================================================== + */ + + byte[] mod_base; + + + /* + ================= + Mod_LoadLighting + ================= + */ + void Mod_LoadLighting(lump_t l) + { + if (l.filelen == 0) + { + loadmodel.lightdata = null; + return; + } + // memcpy (loadmodel.lightdata, mod_base + l.fileofs, l.filelen); + loadmodel.lightdata = new byte[l.filelen]; + System.arraycopy(mod_base, l.fileofs, loadmodel.lightdata, 0, l.filelen); + } + + + /* + ================= + Mod_LoadVisibility + ================= + */ + void Mod_LoadVisibility(lump_t l) + { + int i; + + if (l.filelen == 0) + { + loadmodel.vis = null; + return; + } + + System.arraycopy(mod_base, l.fileofs, model_visibility, 0, l.filelen); + + ByteBuffer bb = ByteBuffer.wrap(model_visibility, 0, l.filelen); + + loadmodel.vis = new qfiles.dvis_t(bb.order(ByteOrder.LITTLE_ENDIAN)); + + /* done: + memcpy (loadmodel.vis, mod_base + l.fileofs, l.filelen); + + loadmodel.vis.numclusters = LittleLong (loadmodel.vis.numclusters); + for (i=0 ; i<loadmodel.vis.numclusters ; i++) + { + loadmodel.vis.bitofs[i][0] = LittleLong (loadmodel.vis.bitofs[i][0]); + loadmodel.vis.bitofs[i][1] = LittleLong (loadmodel.vis.bitofs[i][1]); + } + */ + } + + + /* + ================= + Mod_LoadVertexes + ================= + */ + void Mod_LoadVertexes(lump_t l) + { + mvertex_t[] vertexes; + int i, count; + + if ( (l.filelen % mvertex_t.DISK_SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / mvertex_t.DISK_SIZE; + + vertexes = new mvertex_t[count]; + + loadmodel.vertexes = vertexes; + loadmodel.numvertexes = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + vertexes[i] = new mvertex_t(bb); + } + } + + /* + ================= + RadiusFromBounds + ================= + */ + float RadiusFromBounds(float[] mins, float[] maxs) + { + float[] corner = {0, 0, 0}; + + for (int i=0 ; i<3 ; i++) + { + corner[i] = Math.abs(mins[i]) > Math.abs(maxs[i]) ? Math.abs(mins[i]) : Math.abs(maxs[i]); + } + return Math3D.VectorLength(corner); + } + + + /* + ================= + Mod_LoadSubmodels + ================= + */ + void Mod_LoadSubmodels(lump_t l) { + + if ((l.filelen % qfiles.dmodel_t.SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + + loadmodel.name); + + int i, j; + + int count = l.filelen / qfiles.dmodel_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + mmodel_t out; + mmodel_t[] outs = new mmodel_t[count]; + for (i = 0; i < count; i++) { + outs[i] = new mmodel_t(); + } + + loadmodel.submodels = outs; + loadmodel.numsubmodels = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + qfiles.dmodel_t in; + + for (i = 0; i < count; i++) { + in = new qfiles.dmodel_t(bb); + out = outs[i]; + for (j = 0; j < 3; j++) { // spread the mins / maxs by a + // pixel + out.mins[j] = in.mins[j] - 1; + out.maxs[j] = in.maxs[j] + 1; + out.origin[j] = in.origin[j]; + } + out.radius = RadiusFromBounds(out.mins, out.maxs); + out.headnode = in.headnode; + out.firstface = in.firstface; + out.numfaces = in.numfaces; + } + } + + /* + ================= + Mod_LoadEdges + ================= + */ + void Mod_LoadEdges (lump_t l) + { + medge_t[] edges; + int i, count; + + if ( (l.filelen % medge_t.DISK_SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / medge_t.DISK_SIZE; + // out = Hunk_Alloc ( (count + 1) * sizeof(*out)); + edges = new medge_t[count + 1]; + + loadmodel.edges = edges; + loadmodel.numedges = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + edges[i] = new medge_t(bb); + } + } + + /* + ================= + Mod_LoadTexinfo + ================= + */ + void Mod_LoadTexinfo(lump_t l) + { + texinfo_t in; + mtexinfo_t[] out; + mtexinfo_t step; + int i, j, count; + int next; + String name; + + if ((l.filelen % texinfo_t.SIZE) != 0) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / texinfo_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new mtexinfo_t[count]; + for ( i=0 ; i<count ; i++) { + out[i] = new mtexinfo_t(); + } + + loadmodel.texinfo = out; + loadmodel.numtexinfo = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) { + + in = new texinfo_t(bb); + out[i].vecs = in.vecs; + out[i].flags = in.flags; + next = in.nexttexinfo; + if (next > 0) + out[i].next = loadmodel.texinfo[next]; + else + out[i].next = null; + + name = "textures/" + in.texture + ".wal"; + + out[i].image = GL_FindImage(name, it_wall); + if (out[i].image == null) { + VID.Printf(Defines.PRINT_ALL, "Couldn't load " + name + '\n'); + out[i].image = r_notexture; + } + } + + // count animation frames + for (i=0 ; i<count ; i++) { + out[i].numframes = 1; + for (step = out[i].next ; (step != null) && (step != out[i]) ; step=step.next) + out[i].numframes++; + } + } + + /* + ================ + CalcSurfaceExtents + + Fills in s.texturemins[] and s.extents[] + ================ + */ + void CalcSurfaceExtents(msurface_t s) + { + float[] mins = {0, 0}; + float[] maxs = {0, 0}; + float val; + + int j, e; + mvertex_t v; + int[] bmins = {0, 0}; + int[] bmaxs = {0, 0}; + + mins[0] = mins[1] = 999999; + maxs[0] = maxs[1] = -99999; + + mtexinfo_t tex = s.texinfo; + + for (int i=0 ; i<s.numedges ; i++) + { + e = loadmodel.surfedges[s.firstedge+i]; + if (e >= 0) + v = loadmodel.vertexes[loadmodel.edges[e].v[0]]; + else + v = loadmodel.vertexes[loadmodel.edges[-e].v[1]]; + + for (j=0 ; j<2 ; j++) + { + val = v.position[0] * tex.vecs[j][0] + + v.position[1] * tex.vecs[j][1] + + v.position[2] * tex.vecs[j][2] + + tex.vecs[j][3]; + if (val < mins[j]) + mins[j] = val; + if (val > maxs[j]) + maxs[j] = val; + } + } + + for (int i=0 ; i<2 ; i++) + { + bmins[i] = (int)Math.floor(mins[i]/16); + bmaxs[i] = (int)Math.ceil(maxs[i]/16); + + s.texturemins[i] = (short)(bmins[i] * 16); + s.extents[i] = (short)((bmaxs[i] - bmins[i]) * 16); + + } + } + + /* + ================= + Mod_LoadFaces + ================= + */ + void Mod_LoadFaces(lump_t l) { + + int i, surfnum; + int planenum, side; + int ti; + + if ((l.filelen % qfiles.dface_t.SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + + loadmodel.name); + + int count = l.filelen / qfiles.dface_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + msurface_t[] outs = new msurface_t[count]; + for (i = 0; i < count; i++) { + outs[i] = new msurface_t(); + } + + loadmodel.surfaces = outs; + loadmodel.numsurfaces = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + currentmodel = loadmodel; + + GL_BeginBuildingLightmaps(loadmodel); + + qfiles.dface_t in; + msurface_t out; + + for (surfnum = 0; surfnum < count; surfnum++) { + in = new qfiles.dface_t(bb); + out = outs[surfnum]; + out.firstedge = in.firstedge; + out.numedges = in.numedges; + out.flags = 0; + out.polys = null; + + planenum = in.planenum; + side = in.side; + if (side != 0) + out.flags |= Defines.SURF_PLANEBACK; + + out.plane = loadmodel.planes[planenum]; + + ti = in.texinfo; + if (ti < 0 || ti >= loadmodel.numtexinfo) + Com.Error(Defines.ERR_DROP, + "MOD_LoadBmodel: bad texinfo number"); + + out.texinfo = loadmodel.texinfo[ti]; + + CalcSurfaceExtents(out); + + // lighting info + + for (i = 0; i < Defines.MAXLIGHTMAPS; i++) + out.styles[i] = in.styles[i]; + + i = in.lightofs; + if (i == -1) + out.samples = null; + else { + ByteBuffer pointer = ByteBuffer.wrap(loadmodel.lightdata); + pointer.position(i); + pointer = pointer.slice(); + pointer.mark(); + out.samples = pointer; // subarray + } + + // set the drawing flags + + if ((out.texinfo.flags & Defines.SURF_WARP) != 0) { + out.flags |= Defines.SURF_DRAWTURB; + for (i = 0; i < 2; i++) { + out.extents[i] = 16384; + out.texturemins[i] = -8192; + } + GL_SubdivideSurface(out); // cut up polygon for warps + } + + // create lightmaps and polygons + if ((out.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 + | Defines.SURF_TRANS66 | Defines.SURF_WARP)) == 0) + GL_CreateSurfaceLightmap(out); + + if ((out.texinfo.flags & Defines.SURF_WARP) == 0) + GL_BuildPolygonFromSurface(out); + + } + GL_EndBuildingLightmaps(); + } + + + /* + ================= + Mod_SetParent + ================= + */ + void Mod_SetParent(mnode_t node, mnode_t parent) + { + node.parent = parent; + if (node.contents != -1) return; + Mod_SetParent(node.children[0], node); + Mod_SetParent(node.children[1], node); + } + + /* + ================= + Mod_LoadNodes + ================= + */ + void Mod_LoadNodes(lump_t l) + { + int i, j, count, p; + qfiles.dnode_t in; + mnode_t[] out; + + if ((l.filelen % qfiles.dnode_t.SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dnode_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new mnode_t[count]; + + loadmodel.nodes = out; + loadmodel.numnodes = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + // initialize the tree array + for ( i=0 ; i<count ; i++) out[i] = new mnode_t(); // do first before linking + + // fill and link the nodes + for ( i=0 ; i<count ; i++) + { + in = new qfiles.dnode_t(bb); + for (j=0 ; j<3 ; j++) + { + out[i].mins[j] = in.mins[j]; + out[i].maxs[j] = in.maxs[j]; + } + + p = in.planenum; + out[i].plane = loadmodel.planes[p]; + + out[i].firstsurface = in.firstface; + out[i].numsurfaces = in.numfaces; + out[i].contents = -1; // differentiate from leafs + + for (j=0 ; j<2 ; j++) + { + p = in.children[j]; + if (p >= 0) + out[i].children[j] = loadmodel.nodes[p]; + else + out[i].children[j] = loadmodel.leafs[-1 - p]; // mleaf_t extends mnode_t + } + } + + Mod_SetParent(loadmodel.nodes[0], null); // sets nodes and leafs + } + + /* + ================= + Mod_LoadLeafs + ================= + */ + void Mod_LoadLeafs(lump_t l) + { + qfiles.dleaf_t in; + mleaf_t[] out; + int i, j, count, p; + + if ((l.filelen % qfiles.dleaf_t.SIZE) != 0) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dleaf_t.SIZE; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new mleaf_t[count]; + + loadmodel.leafs = out; + loadmodel.numleafs = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + in = new qfiles.dleaf_t(bb); + out[i] = new mleaf_t(); + for (j=0 ; j<3 ; j++) + { + out[i].mins[j] = in.mins[j]; + out[i].maxs[j] = in.maxs[j]; + + } + + out[i].contents = in.contents; + out[i].cluster = in.cluster; + out[i].area = in.area; + + out[i].setMarkSurface(in.firstleafface, loadmodel.marksurfaces); + out[i].nummarksurfaces = in.numleaffaces; + } + } + + + /* + ================= + Mod_LoadMarksurfaces + ================= + */ + void Mod_LoadMarksurfaces(lump_t l) + { + int i, j, count; + + msurface_t[] out; + + if ((l.filelen % Defines.SIZE_OF_SHORT) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + count = l.filelen / Defines.SIZE_OF_SHORT; + // out = Hunk_Alloc ( count*sizeof(*out)); + out = new msurface_t[count]; + + loadmodel.marksurfaces = out; + loadmodel.nummarksurfaces = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + j = bb.getShort(); + if (j < 0 || j >= loadmodel.numsurfaces) + Com.Error(Defines.ERR_DROP, "Mod_ParseMarksurfaces: bad surface number"); + + out[i] = loadmodel.surfaces[j]; + } + } + + + /* + ================= + Mod_LoadSurfedges + ================= + */ + void Mod_LoadSurfedges(lump_t l) + { + int i, count; + int[] offsets; + + if ( (l.filelen % Defines.SIZE_OF_INT) != 0) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / Defines.SIZE_OF_INT; + if (count < 1 || count >= Defines.MAX_MAP_SURFEDGES) + Com.Error (Defines.ERR_DROP, "MOD_LoadBmodel: bad surfedges count in " + loadmodel.name + ": " + count); + + offsets = new int[count]; + + loadmodel.surfedges = offsets; + loadmodel.numsurfedges = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) offsets[i] = bb.getInt(); + } + + + /* + ================= + Mod_LoadPlanes + ================= + */ + void Mod_LoadPlanes(lump_t l) + { + int i, j; + cplane_t[] out; + qfiles.dplane_t in; + int count; + int bits; + + if ((l.filelen % qfiles.dplane_t.SIZE) != 0) + Com.Error(Defines.ERR_DROP, "MOD_LoadBmodel: funny lump size in " + loadmodel.name); + + count = l.filelen / qfiles.dplane_t.SIZE; + // out = Hunk_Alloc ( count*2*sizeof(*out)); + out = new cplane_t[count * 2]; + for (i = 0; i < count; i++) { + out[i] = new cplane_t(); + } + + loadmodel.planes = out; + loadmodel.numplanes = count; + + ByteBuffer bb = ByteBuffer.wrap(mod_base, l.fileofs, l.filelen); + bb.order(ByteOrder.LITTLE_ENDIAN); + + for ( i=0 ; i<count ; i++) + { + bits = 0; + in = new qfiles.dplane_t(bb); + for (j=0 ; j<3 ; j++) + { + out[i].normal[j] = in.normal[j]; + if (out[i].normal[j] < 0) + bits |= (1<<j); + } + + out[i].dist = in.dist; + out[i].type = (byte)in.type; + out[i].signbits = (byte)bits; + } + } + + /* + ================= + Mod_LoadBrushModel + ================= + */ + void Mod_LoadBrushModel(model_t mod, ByteBuffer buffer) + { + int i; + qfiles.dheader_t header; + mmodel_t bm; + + loadmodel.type = mod_brush; + if (loadmodel != mod_known[0]) + Com.Error(Defines.ERR_DROP, "Loaded a brush model after the world"); + + header = new qfiles.dheader_t(buffer); + + i = header.version; + if (i != Defines.BSPVERSION) + Com.Error (Defines.ERR_DROP, "Mod_LoadBrushModel: " + mod.name + " has wrong version number (" + i + " should be " + Defines.BSPVERSION + ")"); + + mod_base = fileBuffer; //(byte *)header; + + // load into heap + Mod_LoadVertexes(header.lumps[Defines.LUMP_VERTEXES]); // ok + Mod_LoadEdges(header.lumps[Defines.LUMP_EDGES]); // ok + Mod_LoadSurfedges(header.lumps[Defines.LUMP_SURFEDGES]); // ok + Mod_LoadLighting(header.lumps[Defines.LUMP_LIGHTING]); // ok + Mod_LoadPlanes(header.lumps[Defines.LUMP_PLANES]); // ok + Mod_LoadTexinfo(header.lumps[Defines.LUMP_TEXINFO]); // ok + Mod_LoadFaces(header.lumps[Defines.LUMP_FACES]); // ok + Mod_LoadMarksurfaces(header.lumps[Defines.LUMP_LEAFFACES]); + Mod_LoadVisibility(header.lumps[Defines.LUMP_VISIBILITY]); // ok + Mod_LoadLeafs(header.lumps[Defines.LUMP_LEAFS]); // ok + Mod_LoadNodes(header.lumps[Defines.LUMP_NODES]); // ok + Mod_LoadSubmodels(header.lumps[Defines.LUMP_MODELS]); + mod.numframes = 2; // regular and alternate animation + + // + // set up the submodels + // + model_t starmod; + + for (i=0 ; i<mod.numsubmodels ; i++) + { + + bm = mod.submodels[i]; + starmod = mod_inline[i] = loadmodel.copy(); + + starmod.firstmodelsurface = bm.firstface; + starmod.nummodelsurfaces = bm.numfaces; + starmod.firstnode = bm.headnode; + if (starmod.firstnode >= loadmodel.numnodes) + Com.Error(Defines.ERR_DROP, "Inline model " + i + " has bad firstnode"); + + Math3D.VectorCopy(bm.maxs, starmod.maxs); + Math3D.VectorCopy(bm.mins, starmod.mins); + starmod.radius = bm.radius; + + if (i == 0) + loadmodel = starmod.copy(); + + starmod.numleafs = bm.visleafs; + } + } + + /* + ============================================================================== + + ALIAS MODELS + + ============================================================================== + */ + + /* + ================= + Mod_LoadAliasModel + ================= + */ + void Mod_LoadAliasModel (model_t mod, ByteBuffer buffer) + { + int i, j; + qfiles.dmdl_t pheader; + qfiles.dstvert_t[] poutst; + qfiles.dtriangle_t[] pouttri; + qfiles.daliasframe_t[] poutframe; + int[] poutcmd; + + pheader = new qfiles.dmdl_t(buffer); + + if (pheader.version != qfiles.ALIAS_VERSION) + Com.Error(Defines.ERR_DROP, "%s has wrong version number (%i should be %i)", + new Vargs(3).add(mod.name).add(pheader.version).add(qfiles.ALIAS_VERSION)); + + if (pheader.skinheight > MAX_LBM_HEIGHT) + Com.Error(Defines.ERR_DROP, "model "+ mod.name +" has a skin taller than " + MAX_LBM_HEIGHT); + + if (pheader.num_xyz <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no vertices"); + + if (pheader.num_xyz > qfiles.MAX_VERTS) + Com.Error(Defines.ERR_DROP, "model " + mod.name +" has too many vertices"); + + if (pheader.num_st <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no st vertices"); + + if (pheader.num_tris <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no triangles"); + + if (pheader.num_frames <= 0) + Com.Error(Defines.ERR_DROP, "model " + mod.name + " has no frames"); + + // + // load base s and t vertices (not used in gl version) + // + poutst = new qfiles.dstvert_t[pheader.num_st]; + buffer.position(pheader.ofs_st); + for (i=0 ; i<pheader.num_st ; i++) + { + poutst[i] = new qfiles.dstvert_t(buffer); + } + + // + // load triangle lists + // + pouttri = new qfiles.dtriangle_t[pheader.num_tris]; + buffer.position(pheader.ofs_tris); + for (i=0 ; i<pheader.num_tris ; i++) + { + pouttri[i] = new qfiles.dtriangle_t(buffer); + } + + // + // load the frames + // + poutframe = new qfiles.daliasframe_t[pheader.num_frames]; + buffer.position(pheader.ofs_frames); + for (i=0 ; i<pheader.num_frames ; i++) + { + poutframe[i] = new qfiles.daliasframe_t(buffer); + // verts are all 8 bit, so no swapping needed + poutframe[i].verts = new int[pheader.num_xyz]; + for (int k=0; k < pheader.num_xyz; k++) { + poutframe[i].verts[k] = buffer.getInt(); + } + } + + mod.type = mod_alias; + + // + // load the glcmds + // + poutcmd = new int[pheader.num_glcmds]; + buffer.position(pheader.ofs_glcmds); + for (i=0 ; i<pheader.num_glcmds ; i++) + poutcmd[i] = buffer.getInt(); // LittleLong (pincmd[i]); + + // register all skins + String[] skinNames = new String[pheader.num_skins]; + byte[] nameBuf = new byte[qfiles.MAX_SKINNAME]; + buffer.position(pheader.ofs_skins); + for (i=0 ; i<pheader.num_skins ; i++) + { + buffer.get(nameBuf); + skinNames[i] = new String(nameBuf); + int n = skinNames[i].indexOf('\0'); + if (n > -1) { + skinNames[i] = skinNames[i].substring(0, n); + } + mod.skins[i] = GL_FindImage(skinNames[i], it_skin); + } + + // set the model arrays + pheader.skinNames = skinNames; // skin names + pheader.stVerts = poutst; // textur koordinaten + pheader.triAngles = pouttri; // dreiecke + pheader.glCmds = poutcmd; // STRIP or FAN + pheader.aliasFrames = poutframe; // frames mit vertex array + + mod.extradata = pheader; + + mod.mins[0] = -32; + mod.mins[1] = -32; + mod.mins[2] = -32; + mod.maxs[0] = 32; + mod.maxs[1] = 32; + mod.maxs[2] = 32; + + precompileGLCmds(pheader); + } + + /* + ============================================================================== + + SPRITE MODELS + + ============================================================================== + */ + + /* + ================= + Mod_LoadSpriteModel + ================= + */ + void Mod_LoadSpriteModel(model_t mod, ByteBuffer buffer) + { + qfiles.dsprite_t sprout = new qfiles.dsprite_t(buffer); + + if (sprout.version != qfiles.SPRITE_VERSION) + Com.Error(Defines.ERR_DROP, "%s has wrong version number (%i should be %i)", + new Vargs(3).add(mod.name).add(sprout.version).add(qfiles.SPRITE_VERSION)); + + if (sprout.numframes > qfiles.MAX_MD2SKINS) + Com.Error(Defines.ERR_DROP, "%s has too many frames (%i > %i)", + new Vargs(3).add(mod.name).add(sprout.numframes).add(qfiles.MAX_MD2SKINS)); + + for (int i=0 ; i<sprout.numframes ; i++) + { + mod.skins[i] = GL_FindImage(sprout.frames[i].name, it_sprite); + } + + mod.type = mod_sprite; + mod.extradata = sprout; + } + +// ============================================================================= + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_BeginRegistration + + Specifies the model that will be used as the world + @@@@@@@@@@@@@@@@@@@@@ + */ + public void R_BeginRegistration(String model) + { + resetModelArrays(); + Polygon.reset(); + + cvar_t flushmap; + + registration_sequence++; + r_oldviewcluster = -1; // force markleafs + + String fullname = "maps/" + model + ".bsp"; + + // explicitly free the old map if different + // this guarantees that mod_known[0] is the world map + flushmap = Cvar.Get("flushmap", "0", 0); + if ( !mod_known[0].name.equals(fullname) || flushmap.value != 0.0f) + Mod_Free(mod_known[0]); + r_worldmodel = Mod_ForName(fullname, true); + + r_viewcluster = -1; + } + + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_RegisterModel + + @@@@@@@@@@@@@@@@@@@@@ + */ + public model_t R_RegisterModel(String name) + { + model_t mod = null; + int i; + qfiles.dsprite_t sprout; + qfiles.dmdl_t pheader; + + mod = Mod_ForName(name, false); + if (mod != null) + { + mod.registration_sequence = registration_sequence; + + // register any images used by the models + if (mod.type == mod_sprite) + { + sprout = (qfiles.dsprite_t)mod.extradata; + for (i=0 ; i<sprout.numframes ; i++) + mod.skins[i] = GL_FindImage(sprout.frames[i].name, it_sprite); + } + else if (mod.type == mod_alias) + { + pheader = (qfiles.dmdl_t)mod.extradata; + for (i=0 ; i<pheader.num_skins ; i++) + mod.skins[i] = GL_FindImage(pheader.skinNames[i], it_skin); + // PGM + mod.numframes = pheader.num_frames; + // PGM + } + else if (mod.type == mod_brush) + { + for (i=0 ; i<mod.numtexinfo ; i++) + mod.texinfo[i].image.registration_sequence = registration_sequence; + } + } + return mod; + } + + + /* + @@@@@@@@@@@@@@@@@@@@@ + R_EndRegistration + + @@@@@@@@@@@@@@@@@@@@@ + */ + public void R_EndRegistration() + { + model_t mod; + + for (int i=0; i<mod_numknown ; i++) + { + mod = mod_known[i]; + if (mod.name.length() == 0) + continue; + if (mod.registration_sequence != registration_sequence) + { // don't need this model + Mod_Free(mod); + } else { + // precompile AliasModels + if (mod.type == mod_alias) + precompileGLCmds((qfiles.dmdl_t)mod.extradata); + } + } + GL_FreeUnusedImages(); + //modelMemoryUsage(); + } + + +// ============================================================================= + + + /* + ================ + Mod_Free + ================ + */ + void Mod_Free (model_t mod) + { + mod.clear(); + } + + /* + ================ + Mod_FreeAll + ================ + */ + void Mod_FreeAll() + { + for (int i=0 ; i<mod_numknown ; i++) + { + if (mod_known[i].extradata != null) + Mod_Free(mod_known[i]); + } + } + + /* + * new functions for vertex array handling + */ + static final int MODEL_BUFFER_SIZE = 50000; + static FloatBuffer globalModelTextureCoordBuf = Lib.newFloatBuffer(MODEL_BUFFER_SIZE * 2); + static IntBuffer globalModelVertexIndexBuf = Lib.newIntBuffer(MODEL_BUFFER_SIZE); + + void precompileGLCmds(qfiles.dmdl_t model) { + model.textureCoordBuf = globalModelTextureCoordBuf.slice(); + model.vertexIndexBuf = globalModelVertexIndexBuf.slice(); + Vector tmp = new Vector(); + + int count = 0; + int[] order = model.glCmds; + int orderIndex = 0; + while (true) + { + // get the vertex count and primitive type + count = order[orderIndex++]; + if (count == 0) + break; // done + + tmp.addElement(new Integer(count)); + + if (count < 0) + { + count = -count; + //gl.glBegin (GL.GL_TRIANGLE_FAN); + } + else + { + //gl.glBegin (GL.GL_TRIANGLE_STRIP); + } + + do { + // texture coordinates come from the draw list + globalModelTextureCoordBuf.put(Float.intBitsToFloat(order[orderIndex + 0])); + globalModelTextureCoordBuf.put(Float.intBitsToFloat(order[orderIndex + 1])); + globalModelVertexIndexBuf.put(order[orderIndex + 2]); + + orderIndex += 3; + } while (--count != 0); + } + + int size = tmp.size(); + + model.counts = new int[size]; + model.indexElements = new IntBuffer[size]; + + count = 0; + int pos = 0; + for (int i = 0; i < model.counts.length; i++) { + count = ((Integer)tmp.get(i)).intValue(); + model.counts[i] = count; + + count = (count < 0) ? -count : count; + model.vertexIndexBuf.position(pos); + model.indexElements[i] = model.vertexIndexBuf.slice(); + model.indexElements[i].limit(count); + pos += count; + } + } + + static void resetModelArrays() { + globalModelTextureCoordBuf.rewind(); + globalModelVertexIndexBuf.rewind(); + } + + static void modelMemoryUsage() { + System.out.println("AliasModels: globalVertexBuffer size " + globalModelVertexIndexBuf.position()); + } +} diff --git a/src/jake2/render/fast/Polygon.java b/src/jake2/render/fast/Polygon.java new file mode 100644 index 0000000..13019fc --- /dev/null +++ b/src/jake2/render/fast/Polygon.java @@ -0,0 +1,164 @@ +/* + * Polygon.java + * Copyright (C) 2003 + * + * $Id: Polygon.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.render.glpoly_t; +import jake2.util.Lib; + +import java.nio.FloatBuffer; + +/** + * Polygon + * + * @author cwei + */ +public final class Polygon extends glpoly_t { + + private final static int MAX_POLYS = 20000; + + private final static int MAX_BUFFER_VERTICES = 120000; + + // backup for s1 scrolling + private static float[] s1_old = new float[MAX_VERTICES]; + + private static FloatBuffer buffer = Lib.newFloatBuffer(MAX_BUFFER_VERTICES + * STRIDE); + + private static int bufferIndex = 0; + + private static int polyCount = 0; + + private static Polygon[] polyCache = new Polygon[MAX_POLYS]; + static { + for (int i = 0; i < polyCache.length; i++) { + polyCache[i] = new Polygon(); + } + } + + static glpoly_t create(int numverts) { + Polygon poly = polyCache[polyCount++]; + poly.clear(); + poly.numverts = numverts; + poly.pos = bufferIndex; + bufferIndex += numverts; + return poly; + } + + static void reset() { + polyCount = 0; + bufferIndex = 0; + } + + static FloatBuffer getInterleavedBuffer() { + return (FloatBuffer) buffer.rewind(); + } + + private Polygon() { + } + + private final void clear() { + next = null; + chain = null; + numverts = 0; + flags = 0; + } + + // the interleaved buffer has the format: + // textureCoord0 (index 0, 1) + // vertex (index 2, 3, 4) + // textureCoord1 (index 5, 6) + + public final float s1(int index) { + return buffer.get((index + pos) * STRIDE); + } + + public final void s1(int index, float value) { + buffer.put((index + pos) * STRIDE, value); + } + + public final float t1(int index) { + return buffer.get((index + pos) * STRIDE + 1); + } + + public final void t1(int index, float value) { + buffer.put((index + pos) * STRIDE + 1, value); + } + + public final float x(int index) { + return buffer.get((index + pos) * STRIDE + 2); + } + + public final void x(int index, float value) { + buffer.put((index + pos) * STRIDE + 2, value); + } + + public final float y(int index) { + return buffer.get((index + pos) * STRIDE + 3); + } + + public final void y(int index, float value) { + buffer.put((index + pos) * STRIDE + 3, value); + } + + public final float z(int index) { + return buffer.get((index + pos) * STRIDE + 4); + } + + public final void z(int index, float value) { + buffer.put((index + pos) * STRIDE + 4, value); + } + + public final float s2(int index) { + return buffer.get((index + pos) * STRIDE + 5); + } + + public final void s2(int index, float value) { + buffer.put((index + pos) * STRIDE + 5, value); + } + + public final float t2(int index) { + return buffer.get((index + pos) * STRIDE + 6); + } + + public final void t2(int index, float value) { + buffer.put((index + pos) * STRIDE + 6, value); + } + + public final void beginScrolling(float scroll) { + int index = pos * STRIDE; + for (int i = 0; i < numverts; i++, index += STRIDE) { + scroll += s1_old[i] = buffer.get(index); + buffer.put(index, scroll); + } + } + + public final void endScrolling() { + int index = pos * STRIDE; + for (int i = 0; i < numverts; i++, index += STRIDE) { + buffer.put(index, s1_old[i]); + } + } +}
\ No newline at end of file diff --git a/src/jake2/render/fast/Surf.java b/src/jake2/render/fast/Surf.java new file mode 100644 index 0000000..c9312ff --- /dev/null +++ b/src/jake2/render/fast/Surf.java @@ -0,0 +1,1333 @@ +/* + * Surf.java + * Copyright (C) 2003 + * + * $Id: Surf.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.client.*; +import jake2.game.cplane_t; +import jake2.qcommon.Com; +import jake2.render.*; +import jake2.util.Lib; +import jake2.util.Math3D; + +import java.nio.*; +import java.util.Arrays; + +/** + * 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_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]; + IntBuffer lightmap_buffer = Lib.newIntBuffer(BLOCK_WIDTH * BLOCK_HEIGHT, ByteOrder.LITTLE_ENDIAN); + + public gllightmapstate_t() { + for (int i = 0; i < MAX_LIGHTMAPS; i++) + lightmap_surfaces[i] = new msurface_t(); + } + + public void clearLightmapSurfaces() { + for (int i = 0; i < MAX_LIGHTMAPS; i++) + // TODO lightmap_surfaces[i].clear(); + lightmap_surfaces[i] = new msurface_t(); + } + + } + + gllightmapstate_t gl_lms = new gllightmapstate_t(); + + // 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, IntBuffer 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) + { + if (tex.next == null) + return tex.image; + + int c = currententity.frame % tex.numframes; + while (c != 0) + { + tex = tex.next; + c--; + } + + return tex.image; + } + + /** + * DrawGLPoly + */ + void DrawGLPoly(glpoly_t p) + { + gl.glDrawArrays(GL_POLYGON, p.pos, p.numverts); + } + + /** + * DrawGLFlowingPoly + * version that handles scrolling texture + */ + void DrawGLFlowingPoly(glpoly_t p) + { + float scroll = -64 * ( (r_newrefdef.time / 40.0f) - (int)(r_newrefdef.time / 40.0f) ); + if(scroll == 0.0f) + scroll = -64.0f; + p.beginScrolling(scroll); + gl.glDrawArrays(GL_POLYGON, p.pos, p.numverts); + p.endScrolling(); + } + + /** + * R_DrawTriangleOutlines + */ + void R_DrawTriangleOutlines() + { + if (gl_showtris.value == 0) + return; + + gl.glDisable(GL_TEXTURE_2D); + gl.glDisable(GL_DEPTH_TEST); + gl.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++) { + gl.glBegin(GL_LINE_STRIP); + gl.glVertex3f(p.x(0), p.y(0), p.z(0)); + gl.glVertex3f(p.x(j-1), p.y(j-1), p.z(j-1)); + gl.glVertex3f(p.x(j), p.y(j), p.z(j)); + gl.glVertex3f(p.x(0), p.y(0), p.z(0)); + gl.glEnd(); + } + } + } + } + + gl.glEnable(GL_DEPTH_TEST); + gl.glEnable(GL_TEXTURE_2D); + } + + private final IntBuffer temp2 = Lib.newIntBuffer(34 * 34, ByteOrder.LITTLE_ENDIAN); + + /** + * R_RenderBrushPoly + */ + void R_RenderBrushPoly(msurface_t fa) + { + c_brush_polys++; + + image_t image = R_TextureAnimation(fa.texinfo); + + if ((fa.flags & Defines.SURF_DRAWTURB) != 0) + { + GL_Bind( image.texnum ); + + // warp texture, no lightmaps + GL_TexEnv( GL_MODULATE ); + gl.glColor4f( gl_state.inverse_intensity, + gl_state.inverse_intensity, + gl_state.inverse_intensity, + 1.0F ); + EmitWaterPolys (fa); + GL_TexEnv( GL_REPLACE ); + + return; + } + else + { + GL_Bind( image.texnum ); + GL_TexEnv( GL_REPLACE ); + } + + // ====== + // PGM + if((fa.texinfo.flags & Defines.SURF_FLOWING) != 0) + DrawGLFlowingPoly(fa.polys); + else + DrawGLPoly (fa.polys); + // PGM + // ====== + + // ersetzt goto + boolean gotoDynamic = false; + /* + ** check for lightmap modification + */ + int maps; + for ( maps = 0; maps < Defines.MAXLIGHTMAPS && fa.styles[maps] != (byte)255; maps++ ) + { + if ( r_newrefdef.lightstyles[fa.styles[maps] & 0xFF].white != fa.cached_light[maps] ) { + gotoDynamic = true; + break; + } + } + + // this is a hack from cwei + if (maps == 4) maps--; + + // dynamic this frame or dynamic previously + boolean is_dynamic = false; + if ( gotoDynamic || ( fa.dlightframe == r_framecount ) ) + { + // label dynamic: + if ( gl_dynamic.value != 0 ) + { + if (( fa.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP ) ) == 0) + { + is_dynamic = true; + } + } + } + + if ( is_dynamic ) + { + if ( ( (fa.styles[maps] & 0xFF) >= 32 || fa.styles[maps] == 0 ) && ( fa.dlightframe != r_framecount ) ) + { + // ist ersetzt durch temp2: unsigned temp[34*34]; + int smax, tmax; + + smax = (fa.extents[0]>>4)+1; + tmax = (fa.extents[1]>>4)+1; + + R_BuildLightMap( fa, temp2, smax); + R_SetCacheState( fa ); + + GL_Bind( gl_state.lightmap_textures + fa.lightmaptexturenum ); + + gl.glTexSubImage2D( GL_TEXTURE_2D, 0, + fa.light_s, fa.light_t, + smax, tmax, + GL_LIGHTMAP_FORMAT, + GL_UNSIGNED_BYTE, temp2 ); + + 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() + { + r_world_matrix.clear(); + // + // go back to the world matrix + // + gl.glLoadMatrix(r_world_matrix); + + gl.glEnable (GL_BLEND); + GL_TexEnv(GL_MODULATE ); + + + // the textures are prescaled up for a better lighting range, + // so scale it back down + float intens = gl_state.inverse_intensity; + + gl.glInterleavedArrays(GL_T2F_V3F, glpoly_t.BYTE_STRIDE, globalPolygonInterleavedBuf); + + for (msurface_t 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.polys); // PGM + else + DrawGLPoly(s.polys); + } + + GL_TexEnv( GL_REPLACE ); + gl.glColor4f (1,1,1,1); + gl.glDisable (GL_BLEND); + + r_alpha_surfaces = null; + } + + /** + * DrawTextureChains + */ + void DrawTextureChains() + { + c_visible_textures = 0; + + msurface_t s; + image_t image; + int i; + 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_REPLACE ); + } + + // direct buffer + private final IntBuffer temp = Lib.newIntBuffer(128 * 128, ByteOrder.LITTLE_ENDIAN); + + /** + * GL_RenderLightmappedPoly + * @param surf + */ + void GL_RenderLightmappedPoly( msurface_t surf ) + { + + // ersetzt goto + boolean gotoDynamic = false; + int map; + 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] ) { + gotoDynamic = true; + break; + } + } + + // this is a hack from cwei + if (map == 4) map--; + + // dynamic this frame or dynamic previously + boolean is_dynamic = false; + if ( gotoDynamic || ( surf.dlightframe == r_framecount ) ) + { + // label dynamic: + if ( gl_dynamic.value != 0 ) + { + if ( (surf.texinfo.flags & (Defines.SURF_SKY | Defines.SURF_TRANS33 | Defines.SURF_TRANS66 | Defines.SURF_WARP )) == 0 ) + { + is_dynamic = true; + } + } + } + + glpoly_t p; + FloatBuffer texCoord = globalPolygonInterleavedBuf; + image_t image = R_TextureAnimation( surf.texinfo ); + int lmtex = surf.lightmaptexturenum; + + if ( is_dynamic ) + { + // ist raus gezogen worden int[] temp = new int[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, temp, smax); + R_SetCacheState( surf ); + + GL_MBind(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, temp, smax); + + GL_MBind(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(TEXTURE0, image.texnum ); + GL_MBind(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 ) + { + p.beginScrolling(scroll); + gl.glDrawArrays(GL_POLYGON, p.pos, p.numverts); + p.endScrolling(); + } + } + else + { + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glDrawArrays(GL_POLYGON, p.pos, p.numverts); + } + } + // PGM + // ========== + } + else + { + c_brush_polys++; + + GL_MBind(TEXTURE0, image.texnum ); + GL_MBind(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 ) + { + p.beginScrolling(scroll); + gl.glDrawArrays(GL_POLYGON, p.pos, p.numverts); + p.endScrolling(); + } + } + else + { + // PGM + // ========== + for ( p = surf.polys; p != null; p = p.chain ) + { + gl.glDrawArrays(GL_POLYGON, p.pos, p.numverts); + } + + // ========== + // PGM + } + // PGM + // ========== + } + } + + /** + * R_DrawInlineBModel + */ + void R_DrawInlineBModel() + { + // calculate dynamic lighting for bmodel + if ( gl_flashblend.value == 0 ) + { + dlight_t lt; + for (int 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 = currentmodel.surfaces; + //psurf = surfaces[psurfp]; + + if ( (currententity.flags & Defines.RF_TRANSLUCENT) != 0 ) + { + gl.glEnable (GL_BLEND); + gl.glColor4f (1,1,1,0.25f); + GL_TexEnv( GL_MODULATE ); + } + + // + // draw texture + // + msurface_t psurf; + cplane_t pplane; + float dot; + for (int 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 ( (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 ) { + gl.glDisable (GL_BLEND); + gl.glColor4f (1,1,1,1); + GL_TexEnv( GL_REPLACE ); + } + } + + // stack variable + private final float[] mins = {0, 0, 0}; + private final float[] maxs = {0, 0, 0}; + private final float[] org = {0, 0, 0}; + private final float[] forward = {0, 0, 0}; + private final float[] right = {0, 0, 0}; + private final float[] up = {0, 0, 0}; + /** + * R_DrawBrushModel + */ + void R_DrawBrushModel(entity_t e) + { + if (currentmodel.nummodelsurfaces == 0) + return; + + currententity = e; + gl_state.currenttextures[0] = gl_state.currenttextures[1] = -1; + + boolean rotated; + if (e.angles[0] != 0 || e.angles[1] != 0 || e.angles[2] != 0) + { + rotated = true; + for (int i=0 ; i<3 ; i++) + { + mins[i] = e.origin[i] - currentmodel.radius; + maxs[i] = e.origin[i] + currentmodel.radius; + } + } + else + { + rotated = false; + Math3D.VectorAdd(e.origin, currentmodel.mins, mins); + Math3D.VectorAdd(e.origin, currentmodel.maxs, maxs); + } + + if (R_CullBox(mins, maxs)) return; + + gl.glColor3f (1,1,1); + + // memset (gl_lms.lightmap_surfaces, 0, sizeof(gl_lms.lightmap_surfaces)); + + // TODO wird beim multitexturing nicht gebraucht + //gl_lms.clearLightmapSurfaces(); + + Math3D.VectorSubtract (r_newrefdef.vieworg, e.origin, modelorg); + if (rotated) + { + Math3D.VectorCopy (modelorg, org); + Math3D.AngleVectors (e.angles, forward, right, up); + modelorg[0] = Math3D.DotProduct (org, forward); + modelorg[1] = -Math3D.DotProduct (org, right); + modelorg[2] = Math3D.DotProduct (org, 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(TEXTURE0); + GL_TexEnv( GL_REPLACE ); + gl.glInterleavedArrays(GL_T2F_V3F, glpoly_t.BYTE_STRIDE, globalPolygonInterleavedBuf); + GL_SelectTexture(TEXTURE1); + GL_TexEnv( GL_MODULATE ); + gl.glTexCoordPointer(2, glpoly_t.BYTE_STRIDE, globalPolygonTexCoord1Buf); + gl.glEnableClientState(GL_TEXTURE_COORD_ARRAY); + + R_DrawInlineBModel(); + + gl.glClientActiveTextureARB(TEXTURE1); + gl.glDisableClientState(GL_TEXTURE_COORD_ARRAY); + + GL_EnableMultitexture( false ); + + gl.glPopMatrix(); + } + + /* + ============================================================= + + WORLD MODEL + + ============================================================= + */ + + /** + * R_RecursiveWorldNode + */ + void R_RecursiveWorldNode (mnode_t node) + { + if (node.contents == Defines.CONTENTS_SOLID) + return; // solid + + if (node.visframe != r_visframecount) + return; + + if (R_CullBox(node.mins, node.maxs)) + return; + + int c; + msurface_t mark; + // if a leaf node, draw stuff + if (node.contents != -1) + { + mleaf_t 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 + cplane_t plane = node.plane; + float dot; + 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; + } + + int side, sidebit; + 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 + msurface_t surf; + image_t image; + //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 ( ( 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]); + } + + private final entity_t worldEntity = new entity_t(); + + /** + * R_DrawWorld + */ + void R_DrawWorld() + { + if (r_drawworld.value == 0) + return; + + if ( (r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0 ) + return; + + currentmodel = r_worldmodel; + + Math3D.VectorCopy(r_newrefdef.vieworg, modelorg); + + entity_t ent = worldEntity; + // auto cycle the world frame for texture animation + ent.clear(); + 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)); + // TODO wird bei multitexture nicht gebraucht + //gl_lms.clearLightmapSurfaces(); + + R_ClearSkyBox(); + + GL_EnableMultitexture( true ); + + GL_SelectTexture(TEXTURE0); + GL_TexEnv( GL_REPLACE ); + gl.glInterleavedArrays(GL_T2F_V3F, glpoly_t.BYTE_STRIDE, globalPolygonInterleavedBuf); + GL_SelectTexture(TEXTURE1); + gl.glTexCoordPointer(2, glpoly_t.BYTE_STRIDE, globalPolygonTexCoord1Buf); + gl.glEnableClientState(GL_TEXTURE_COORD_ARRAY); + + if ( gl_lightmap.value != 0) + GL_TexEnv( GL_REPLACE ); + else + GL_TexEnv( GL_MODULATE ); + + R_RecursiveWorldNode(r_worldmodel.nodes[0]); // root node + + gl.glClientActiveTextureARB(TEXTURE1); + gl.glDisableClientState(GL_TEXTURE_COORD_ARRAY); + + GL_EnableMultitexture( false ); + + DrawTextureChains(); + R_DrawSkyBox(); + R_DrawTriangleOutlines(); + } + + final 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() + { + 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; + + int i; + 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; + } + + byte[] vis = Mod_ClusterPVS(r_viewcluster, r_worldmodel); + int c; + // 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) >> 3); + vis = Mod_ClusterPVS(r_viewcluster2, r_worldmodel); + c = (r_worldmodel.numleafs + 31) >> 5; + c <<= 2; + for (int k=0 ; k<c ; k+=4) { + fatvis[k] |= vis[k]; + fatvis[k + 1] |= vis[k + 1]; + fatvis[k + 2] |= vis[k + 2]; + fatvis[k + 3] |= vis[k + 3]; + } + + vis = fatvis; + } + + mnode_t node; + mleaf_t leaf; + int cluster; + 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 + + ============================================================================= + */ + + /** + * LM_InitBlock + */ + void LM_InitBlock() + { + Arrays.fill(gl_lms.allocated, 0); + } + + /** + * LM_UploadBlock + * @param dynamic + */ + void LM_UploadBlock( boolean dynamic ) + { + int texture = ( dynamic ) ? 0 : gl_lms.current_lightmap_texture; + + GL_Bind( gl_state.lightmap_textures + texture ); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + gl_lms.lightmap_buffer.rewind(); + if ( dynamic ) + { + int height = 0; + for (int i = 0; i < BLOCK_WIDTH; i++ ) + { + if ( gl_lms.allocated[i] > height ) + height = gl_lms.allocated[i]; + } + + gl.glTexSubImage2D( GL_TEXTURE_2D, + 0, + 0, 0, + BLOCK_WIDTH, height, + GL_LIGHTMAP_FORMAT, + GL_UNSIGNED_BYTE, + gl_lms.lightmap_buffer ); + } + else + { + gl.glTexImage2D( GL_TEXTURE_2D, + 0, + gl_lms.internal_format, + BLOCK_WIDTH, BLOCK_HEIGHT, + 0, + GL_LIGHTMAP_FORMAT, + GL_UNSIGNED_BYTE, + gl_lms.lightmap_buffer ); + if ( ++gl_lms.current_lightmap_texture == MAX_LIGHTMAPS ) + Com.Error( Defines.ERR_DROP, "LM_UploadBlock() - MAX_LIGHTMAPS exceeded\n" ); + + //debugLightmap(gl_lms.lightmap_buffer, 128, 128, 4); + } + } + + /** + * LM_AllocBlock + * @param w + * @param h + * @param pos + * @return a texture number and the position inside it + */ + boolean LM_AllocBlock (int w, int h, pos_t pos) + { + int best = BLOCK_HEIGHT; + int x = pos.x; + int y = pos.y; + + int best2; + int i, j; + 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) + { + // reconstruct the polygon + medge_t[] pedges = currentmodel.edges; + int lnumverts = fa.numedges; + int vertpage = 0; + // + // draw texture + // + // poly = Hunk_Alloc (sizeof(glpoly_t) + (lnumverts-4) * VERTEXSIZE*sizeof(float)); + glpoly_t poly = Polygon.create(lnumverts); + + poly.next = fa.polys; + poly.flags = fa.flags; + fa.polys = poly; + + int lindex; + float[] vec; + medge_t r_pedge; + float s, t; + for (int 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; + + poly.x(i, vec[0]); + poly.y(i, vec[1]); + poly.z(i, vec[2]); + + poly.s1(i, s); + poly.t1(i, 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.s2(i, s); + poly.t2(i, t); + } + } + + /** + * GL_CreateSurfaceLightmap + */ + void GL_CreateSurfaceLightmap(msurface_t surf) + { + if ( (surf.flags & (Defines.SURF_DRAWSKY | Defines.SURF_DRAWTURB)) != 0) + return; + + int smax = (surf.extents[0]>>4)+1; + int 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 ) ) + { + Com.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; + + IntBuffer base = gl_lms.lightmap_buffer; + base.position(surf.light_t * BLOCK_WIDTH + surf.light_s); + + R_SetCacheState( surf ); + R_BuildLightMap(surf, base.slice(), BLOCK_WIDTH); + } + + lightstyle_t[] lightstyles; + private final IntBuffer dummy = Lib.newIntBuffer(128*128); + + /** + * GL_BeginBuildingLightmaps + */ + void GL_BeginBuildingLightmaps(model_t m) + { + // static lightstyle_t lightstyles[MAX_LIGHTSTYLES]; + int i; + + // 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(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_INTENSITY8; + } + else if ( format == 'L' ) + { + gl_lms.internal_format = 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_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl.glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + gl.glTexImage2D( GL_TEXTURE_2D, + 0, + gl_lms.internal_format, + BLOCK_WIDTH, BLOCK_HEIGHT, + 0, + GL_LIGHTMAP_FORMAT, + GL_UNSIGNED_BYTE, + dummy ); + } + + /** + * GL_EndBuildingLightmaps + */ + void GL_EndBuildingLightmaps() + { + LM_UploadBlock( false ); + GL_EnableMultitexture( false ); + } + + /* + * new buffers for vertex array handling + */ + static FloatBuffer globalPolygonInterleavedBuf = Polygon.getInterleavedBuffer(); + static FloatBuffer globalPolygonTexCoord1Buf = null; + + static { + globalPolygonInterleavedBuf.position(glpoly_t.STRIDE - 2); + globalPolygonTexCoord1Buf = globalPolygonInterleavedBuf.slice(); + globalPolygonInterleavedBuf.position(0); + }; + + //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); +// +// } + +} diff --git a/src/jake2/render/fast/Warp.java b/src/jake2/render/fast/Warp.java new file mode 100644 index 0000000..bb0cc81 --- /dev/null +++ b/src/jake2/render/fast/Warp.java @@ -0,0 +1,716 @@ +/* + * Warp.java + * Copyright (C) 2003 + * + * $Id: Warp.java,v 1.2 2006-11-21 00:50:46 cawe 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.fast; + +import jake2.Defines; +import jake2.Globals; +import jake2.qcommon.Com; +import jake2.render.*; +import jake2.util.Math3D; +import jake2.util.Vec3Cache; + +/** + * Warp + * + * @author cwei + */ +public abstract class Warp extends Model { + // warpsin.h + public static final float[] SIN = { + 0f, 0.19633f, 0.392541f, 0.588517f, 0.784137f, 0.979285f, 1.17384f, 1.3677f, + 1.56072f, 1.75281f, 1.94384f, 2.1337f, 2.32228f, 2.50945f, 2.69512f, 2.87916f, + 3.06147f, 3.24193f, 3.42044f, 3.59689f, 3.77117f, 3.94319f, 4.11282f, 4.27998f, + 4.44456f, 4.60647f, 4.76559f, 4.92185f, 5.07515f, 5.22538f, 5.37247f, 5.51632f, + 5.65685f, 5.79398f, 5.92761f, 6.05767f, 6.18408f, 6.30677f, 6.42566f, 6.54068f, + 6.65176f, 6.75883f, 6.86183f, 6.9607f, 7.05537f, 7.14579f, 7.23191f, 7.31368f, + 7.39104f, 7.46394f, 7.53235f, 7.59623f, 7.65552f, 7.71021f, 7.76025f, 7.80562f, + 7.84628f, 7.88222f, 7.91341f, 7.93984f, 7.96148f, 7.97832f, 7.99036f, 7.99759f, + 8f, 7.99759f, 7.99036f, 7.97832f, 7.96148f, 7.93984f, 7.91341f, 7.88222f, + 7.84628f, 7.80562f, 7.76025f, 7.71021f, 7.65552f, 7.59623f, 7.53235f, 7.46394f, + 7.39104f, 7.31368f, 7.23191f, 7.14579f, 7.05537f, 6.9607f, 6.86183f, 6.75883f, + 6.65176f, 6.54068f, 6.42566f, 6.30677f, 6.18408f, 6.05767f, 5.92761f, 5.79398f, + 5.65685f, 5.51632f, 5.37247f, 5.22538f, 5.07515f, 4.92185f, 4.76559f, 4.60647f, + 4.44456f, 4.27998f, 4.11282f, 3.94319f, 3.77117f, 3.59689f, 3.42044f, 3.24193f, + 3.06147f, 2.87916f, 2.69512f, 2.50945f, 2.32228f, 2.1337f, 1.94384f, 1.75281f, + 1.56072f, 1.3677f, 1.17384f, 0.979285f, 0.784137f, 0.588517f, 0.392541f, 0.19633f, + 9.79717e-16f, -0.19633f, -0.392541f, -0.588517f, -0.784137f, -0.979285f, -1.17384f, -1.3677f, + -1.56072f, -1.75281f, -1.94384f, -2.1337f, -2.32228f, -2.50945f, -2.69512f, -2.87916f, + -3.06147f, -3.24193f, -3.42044f, -3.59689f, -3.77117f, -3.94319f, -4.11282f, -4.27998f, + -4.44456f, -4.60647f, -4.76559f, -4.92185f, -5.07515f, -5.22538f, -5.37247f, -5.51632f, + -5.65685f, -5.79398f, -5.92761f, -6.05767f, -6.18408f, -6.30677f, -6.42566f, -6.54068f, + -6.65176f, -6.75883f, -6.86183f, -6.9607f, -7.05537f, -7.14579f, -7.23191f, -7.31368f, + -7.39104f, -7.46394f, -7.53235f, -7.59623f, -7.65552f, -7.71021f, -7.76025f, -7.80562f, + -7.84628f, -7.88222f, -7.91341f, -7.93984f, -7.96148f, -7.97832f, -7.99036f, -7.99759f, + -8f, -7.99759f, -7.99036f, -7.97832f, -7.96148f, -7.93984f, -7.91341f, -7.88222f, + -7.84628f, -7.80562f, -7.76025f, -7.71021f, -7.65552f, -7.59623f, -7.53235f, -7.46394f, + -7.39104f, -7.31368f, -7.23191f, -7.14579f, -7.05537f, -6.9607f, -6.86183f, -6.75883f, + -6.65176f, -6.54068f, -6.42566f, -6.30677f, -6.18408f, -6.05767f, -5.92761f, -5.79398f, + -5.65685f, -5.51632f, -5.37247f, -5.22538f, -5.07515f, -4.92185f, -4.76559f, -4.60647f, + -4.44456f, -4.27998f, -4.11282f, -3.94319f, -3.77117f, -3.59689f, -3.42044f, -3.24193f, + -3.06147f, -2.87916f, -2.69512f, -2.50945f, -2.32228f, -2.1337f, -1.94384f, -1.75281f, + -1.56072f, -1.3677f, -1.17384f, -0.979285f, -0.784137f, -0.588517f, -0.392541f, -0.19633f + }; + + String skyname; + float skyrotate; + float[] skyaxis = {0, 0, 0}; + image_t[] sky_images = new image_t[6]; + + msurface_t warpface; + + static final int SUBDIVIDE_SIZE = 64; + + /** + * BoundPoly + * @param numverts + * @param verts + * @param mins + * @param maxs + */ + void BoundPoly(int numverts, float[][] verts, float[] mins, float[] maxs) { + mins[0] = mins[1] = mins[2] = 9999; + maxs[0] = maxs[1] = maxs[2] = -9999; + + int j; + float[] v; + for (int i=0 ; i<numverts ; i++) { + v = verts[i]; + for (j=0 ; j<3 ; j++) { + if (v[j] < mins[j]) + mins[j] = v[j]; + if (v[j] > maxs[j]) + maxs[j] = v[j]; + } + } + } + + /** + * SubdividePolygon + * @param numverts + * @param verts + */ + void SubdividePolygon(int numverts, float[][] verts) + { + int i, j, k; + float m; + float[][] front = new float[64][3]; + float[][] back = new float[64][3]; + + int f, b; + float[] dist = new float[64]; + float frac; + + if (numverts > 60) + Com.Error(Defines.ERR_DROP, "numverts = " + numverts); + + float[] mins = Vec3Cache.get(); + float[] maxs = Vec3Cache.get(); + + BoundPoly(numverts, verts, mins, maxs); + float[] v; + // x,y und z + for (i=0 ; i<3 ; i++) + { + m = (mins[i] + maxs[i]) * 0.5f; + m = SUBDIVIDE_SIZE * (float)Math.floor(m / SUBDIVIDE_SIZE + 0.5f); + if (maxs[i] - m < 8) + continue; + if (m - mins[i] < 8) + continue; + + // cut it + for (j=0 ; j<numverts ; j++) { + dist[j] = verts[j][i] - m; + } + + // wrap cases + dist[j] = dist[0]; + + Math3D.VectorCopy(verts[0], verts[numverts]); + + f = b = 0; + for (j=0 ; j<numverts ; j++) + { + v = verts[j]; + if (dist[j] >= 0) + { + Math3D.VectorCopy(v, front[f]); + f++; + } + if (dist[j] <= 0) + { + Math3D.VectorCopy(v, back[b]); + b++; + } + if (dist[j] == 0 || dist[j+1] == 0) continue; + + if ( (dist[j] > 0) != (dist[j+1] > 0) ) + { + // clip point + frac = dist[j] / (dist[j] - dist[j+1]); + for (k=0 ; k<3 ; k++) + front[f][k] = back[b][k] = v[k] + frac*(verts[j+1][k] - v[k]); + + f++; + b++; + } + } + + SubdividePolygon(f, front); + SubdividePolygon(b, back); + + Vec3Cache.release(2); // mins, maxs + return; + } + + Vec3Cache.release(2); // mins, maxs + + // add a point in the center to help keep warp valid + + // wird im Konstruktor erschlagen + // poly = Hunk_Alloc (sizeof(glpoly_t) + ((numverts-4)+2) * VERTEXSIZE*sizeof(float)); + + // init polys + glpoly_t poly = Polygon.create(numverts + 2); + + poly.next = warpface.polys; + warpface.polys = poly; + + float[] total = Vec3Cache.get(); + Math3D.VectorClear(total); + float total_s = 0; + float total_t = 0; + float s, t; + for (i = 0; i < numverts; i++) { + poly.x(i + 1, verts[i][0]); + poly.y(i + 1, verts[i][1]); + poly.z(i + 1, verts[i][2]); + s = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[0]); + t = Math3D.DotProduct(verts[i], warpface.texinfo.vecs[1]); + + total_s += s; + total_t += t; + Math3D.VectorAdd(total, verts[i], total); + + poly.s1(i + 1, s); + poly.t1(i + 1, t); + } + + float scale = 1.0f / numverts; + poly.x(0, total[0] * scale); + poly.y(0, total[1] * scale); + poly.z(0, total[2] * scale); + poly.s1(0, total_s * scale); + poly.t1(0, total_t * scale); + + poly.x(i + 1, poly.x(1)); + poly.y(i + 1, poly.y(1)); + poly.z(i + 1, poly.z(1)); + poly.s1(i + 1, poly.s1(1)); + poly.t1(i + 1, poly.t1(1)); + poly.s2(i + 1, poly.s2(1)); + poly.t2(i + 1, poly.t2(1)); + + Vec3Cache.release(); // total + } + + private final float[][] tmpVerts = new float[64][3]; + /** + * GL_SubdivideSurface + * Breaks a polygon up along axial 64 unit + * boundaries so that turbulent and sky warps + * can be done reasonably. + */ + void GL_SubdivideSurface(msurface_t fa) { + float[][] verts = tmpVerts; + float[] vec; + warpface = fa; + // + // convert edges back to a normal polygon + // + int numverts = 0; + for (int i = 0; i < fa.numedges; i++) { + int lindex = loadmodel.surfedges[fa.firstedge + i]; + + if (lindex > 0) + vec = loadmodel.vertexes[loadmodel.edges[lindex].v[0]].position; + else + vec = loadmodel.vertexes[loadmodel.edges[-lindex].v[1]].position; + Math3D.VectorCopy(vec, verts[numverts]); + numverts++; + } + SubdividePolygon(numverts, verts); + } + +// ========================================================= + static final float TURBSCALE = (float)(256.0f / (2 * Math.PI)); + + /** + * EmitWaterPolys + * 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; + + gl.glBegin(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); + + gl.glTexCoord2f(s, t); + gl.glVertex3f(p.x(i), p.y(i), p.z(i)); + } + gl.glEnd(); + } + } + +// =================================================================== + + float[][] skyclip = { + { 1, 1, 0}, + { 1, -1, 0}, + { 0, -1, 1}, + { 0, 1, 1}, + { 1, 0, 1}, + {-1, 0, 1} + }; + + int c_sky; + + // 1 = s, 2 = t, 3 = 2048 + int[][] st_to_vec = + { + {3,-1,2}, + {-3,1,2}, + + {1,3,2}, + {-1,-3,2}, + + {-2,-1,3}, // 0 degrees yaw, look straight up + {2,-1,-3} // look straight down + + }; + + int[][] vec_to_st = + { + {-2,3,1}, + {2,3,-1}, + + {1,3,2}, + {-1,3,-2}, + + {-2,-1,3}, + {-2,1,-3} + + }; + + float[][] skymins = new float[2][6]; + float[][] skymaxs = new float[2][6]; + float sky_min, sky_max; + + // stack variable + private final float[] v = {0, 0, 0}; + private final float[] av = {0, 0, 0}; + /** + * DrawSkyPolygon + * @param nump + * @param vecs + */ + void DrawSkyPolygon(int nump, float[][] vecs) + { + c_sky++; + // decide which face it maps to + Math3D.VectorCopy(Globals.vec3_origin, v); + int i, axis; + for (i=0; i<nump ; i++) + { + Math3D.VectorAdd(vecs[i], v, v); + } + av[0] = Math.abs(v[0]); + av[1] = Math.abs(v[1]); + av[2] = Math.abs(v[2]); + if (av[0] > av[1] && av[0] > av[2]) + { + if (v[0] < 0) + axis = 1; + else + axis = 0; + } + else if (av[1] > av[2] && av[1] > av[0]) + { + if (v[1] < 0) + axis = 3; + else + axis = 2; + } + else + { + if (v[2] < 0) + axis = 5; + else + axis = 4; + } + + // project new texture coords + float s, t, dv; + int j; + for (i=0 ; i<nump ; i++) + { + j = vec_to_st[axis][2]; + if (j > 0) + dv = vecs[i][j - 1]; + else + dv = -vecs[i][-j - 1]; + if (dv < 0.001f) + continue; // don't divide by zero + j = vec_to_st[axis][0]; + if (j < 0) + s = -vecs[i][-j -1] / dv; + else + s = vecs[i][j-1] / dv; + j = vec_to_st[axis][1]; + if (j < 0) + t = -vecs[i][-j -1] / dv; + else + t = vecs[i][j-1] / dv; + + if (s < skymins[0][axis]) + skymins[0][axis] = s; + if (t < skymins[1][axis]) + skymins[1][axis] = t; + if (s > skymaxs[0][axis]) + skymaxs[0][axis] = s; + if (t > skymaxs[1][axis]) + skymaxs[1][axis] = t; + } + } + + static final float ON_EPSILON = 0.1f; // point on plane side epsilon + static final int MAX_CLIP_VERTS = 64; + + static final int SIDE_BACK = 1; + static final int SIDE_FRONT = 0; + static final int SIDE_ON = 2; + + float[] dists = new float[MAX_CLIP_VERTS]; + int[] sides = new int[MAX_CLIP_VERTS]; + float[][][][] newv = new float[6][2][MAX_CLIP_VERTS][3]; + + /** + * ClipSkyPolygon + * @param nump + * @param vecs + * @param stage + */ + void ClipSkyPolygon(int nump, float[][] vecs, int stage) + { + if (nump > MAX_CLIP_VERTS-2) + Com.Error(Defines.ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS"); + if (stage == 6) + { // fully clipped, so draw it + DrawSkyPolygon(nump, vecs); + return; + } + + boolean front = false; + boolean back = false; + float[] norm = skyclip[stage]; + + int i; + float d; + for (i=0 ; i<nump ; i++) + { + d = Math3D.DotProduct(vecs[i], norm); + if (d > ON_EPSILON) + { + front = true; + sides[i] = SIDE_FRONT; + } + else if (d < -ON_EPSILON) + { + back = true; + sides[i] = SIDE_BACK; + } + else + sides[i] = SIDE_ON; + dists[i] = d; + } + + if (!front || !back) + { // not clipped + ClipSkyPolygon (nump, vecs, stage+1); + return; + } + + // clip it + sides[i] = sides[0]; + dists[i] = dists[0]; + Math3D.VectorCopy(vecs[0], vecs[i]); + + int newc0 = 0; int newc1 = 0; + float[] v; + float e; + int j; + for (i=0; i<nump ; i++) + { + v = vecs[i]; + switch (sides[i]) + { + case SIDE_FRONT: + Math3D.VectorCopy(v, newv[stage][0][newc0]); + newc0++; + break; + case SIDE_BACK: + Math3D.VectorCopy(v, newv[stage][1][newc1]); + newc1++; + break; + case SIDE_ON: + Math3D.VectorCopy(v, newv[stage][0][newc0]); + newc0++; + Math3D.VectorCopy (v, newv[stage][1][newc1]); + newc1++; + break; + } + + if (sides[i] == SIDE_ON || sides[i+1] == SIDE_ON || sides[i+1] == sides[i]) + continue; + + d = dists[i] / (dists[i] - dists[i+1]); + for (j=0 ; j<3 ; j++) + { + e = v[j] + d * (vecs[i + 1][j] - v[j]); + newv[stage][0][newc0][j] = e; + newv[stage][1][newc1][j] = e; + } + newc0++; + newc1++; + } + + // continue + ClipSkyPolygon(newc0, newv[stage][0], stage+1); + ClipSkyPolygon(newc1, newv[stage][1], stage+1); + } + + float[][] verts = new float[MAX_CLIP_VERTS][3]; + + /** + * R_AddSkySurface + */ + void R_AddSkySurface(msurface_t fa) + { + // calculate vertex values for sky box + for (glpoly_t p = fa.polys; p != null; p = p.next) { + for (int i = 0; i < p.numverts; i++) { + verts[i][0] = p.x(i) - r_origin[0]; + verts[i][1] = p.y(i) - r_origin[1]; + verts[i][2] = p.z(i) - r_origin[2]; + } + ClipSkyPolygon(p.numverts, verts, 0); + } + } + + /** + * R_ClearSkyBox + */ + void R_ClearSkyBox() + { + float[] skymins0 = skymins[0]; + float[] skymins1 = skymins[1]; + float[] skymaxs0 = skymaxs[0]; + float[] skymaxs1 = skymaxs[1]; + + for (int i=0 ; i<6 ; i++) + { + skymins0[i] = skymins1[i] = 9999; + skymaxs0[i] = skymaxs1[i] = -9999; + } + } + + // stack variable + private final float[] v1 = {0, 0, 0}; + private final float[] b = {0, 0, 0}; + /** + * MakeSkyVec + * @param s + * @param t + * @param axis + */ + void MakeSkyVec(float s, float t, int axis) + { + b[0] = s*2300; + b[1] = t*2300; + b[2] = 2300; + + int j, k; + for (j=0 ; j<3 ; j++) + { + k = st_to_vec[axis][j]; + if (k < 0) + v1[j] = -b[-k - 1]; + else + v1[j] = b[k - 1]; + } + + // avoid bilerp seam + s = (s + 1) * 0.5f; + t = (t + 1) * 0.5f; + + if (s < sky_min) + s = sky_min; + else if (s > sky_max) + s = sky_max; + if (t < sky_min) + t = sky_min; + else if (t > sky_max) + t = sky_max; + + t = 1.0f - t; + gl.glTexCoord2f (s, t); + gl.glVertex3f(v1[0], v1[1], v1[2]); + } + + int[] skytexorder = {0,2,1,3,4,5}; + + /** + * R_DrawSkyBox + */ + 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 + } + + gl.glPushMatrix (); + gl.glTranslatef (r_origin[0], r_origin[1], r_origin[2]); + gl.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); + + gl.glBegin(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); + gl.glEnd (); + } + gl.glPopMatrix (); + } + + // 3dstudio environment map names + String[] suf = {"rt", "bk", "lf", "ft", "up", "dn"}; + + /** + * R_SetSky + * @param name + * @param rotate + * @param axis + */ + public void R_SetSky(String name, float rotate, float[] axis) + { + assert (axis.length == 3) : "vec3_t bug"; + String pathname; + skyname = name; + + skyrotate = rotate; + Math3D.VectorCopy(axis, skyaxis); + + for (int i=0 ; i<6 ; i++) + { + // chop down rotating skies for less memory + if (gl_skymip.value != 0 || skyrotate != 0) + gl_picmip.value++; + + if ( qglColorTableEXT && gl_ext_palettedtexture.value != 0) { + // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.pcx", skyname, suf[i]); + pathname = "env/" + skyname + suf[i] + ".pcx"; + } else { + // Com_sprintf (pathname, sizeof(pathname), "env/%s%s.tga", skyname, suf[i]); + pathname = "env/" + skyname + suf[i] + ".tga"; + } + + sky_images[i] = GL_FindImage(pathname, it_sky); + + if (sky_images[i] == null) + sky_images[i] = r_notexture; + + if (gl_skymip.value != 0 || skyrotate != 0) + { // take less memory + gl_picmip.value--; + sky_min = 1.0f / 256; + sky_max = 255.0f / 256; + } + else + { + sky_min = 1.0f / 512; + sky_max = 511.0f / 512; + } + } + } +}
\ No newline at end of file diff --git a/src/jake2/render/fastjogl/GLWrapJogl.java b/src/jake2/render/fastjogl/GLWrapJogl.java deleted file mode 100644 index 6b42e96..0000000 --- a/src/jake2/render/fastjogl/GLWrapJogl.java +++ /dev/null @@ -1,247 +0,0 @@ -/* -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. - -*/ - -// Created on 28.10.2006 by RST. - -// $Id: GLWrapJogl.java,v 1.1 2006-10-31 13:06:31 salomo Exp $ - -package jake2.render.fastjogl; - - -import java.nio.*; - -import net.java.games.jogl.GL; -import jake2.*; -import jake2.client.*; -import jake2.game.*; -import jake2.qcommon.*; -import jake2.render.*; -import jake2.render.common.GenericGL; -import jake2.server.*; -import net.java.games.jogl.*; - -public class GLWrapJogl implements GenericGL{ - - protected GL gl; - - public GLWrapJogl(GL gl) - { - this.gl = gl; - } - - public void glTexParameterf(int gl_texture_2d, int gl_texture_min_filter, int gl_nearest) { - gl.glTexParameterf(gl_texture_2d, gl_texture_min_filter, gl_nearest); - } - public void glBegin(int gl_triangle_fan2) { - gl.glBegin(gl_triangle_fan2); - } - - public void glTexCoord2f(float s, float t) { - gl.glTexCoord2f(s, t); - } - - public void glVertex3f(float f, float g, float h) { - gl.glVertex3f(f, g, h); - } - - public void glEnd() { - gl.glEnd(); - } - - public void glPushMatrix() { - gl.glPushMatrix(); - } - - public void glTranslatef(float f, float g, float h) { - gl.glTranslatef(f, g, h); - } - - public void glRotatef(float f, float g, float h, float i) { - gl.glRotatef(f, g, h, i); - } - - public void glPopMatrix() { - gl.glPopMatrix(); - } - - public void glColor3f(float f, float g, float h) { - gl.glColor3f(f, g, h); - } - - public void glDepthMask(boolean b) { - gl.glDepthMask(b); - } - - public void glDisable(int gl_texture_2d2) { - gl.glDisable(gl_texture_2d2); - } - - public void glBlendFunc(int gl_src_alpha2, int gl_one_minus_src_alpha2) { - gl.glBlendFunc(gl_src_alpha2, gl_one_minus_src_alpha2); - } - - public void glShadeModel(int gl_smooth2) { - gl.glShadeModel(gl_smooth2); - } - - public void glDrawArrays(int gl_polygon2, int pos, int numverts) { - gl.glDrawArrays(gl_polygon2, pos, numverts); - } - - public void glBindTexture(int gl_texture_2d2, int texnum) { - gl.glBindTexture(gl_texture_2d2, texnum); - } - - public void glActiveTextureARB(int texture) { - gl.glActiveTextureARB( texture); - } - - public void glClientActiveTextureARB(int texture) { - gl.glClientActiveTextureARB(texture); - } - - public void glTexEnvi(int gl_texture_env2, int gl_texture_env_mode2, int mode) { - gl.glTexEnvi(gl_texture_env2, gl_texture_env_mode2, mode); - } - - public void glVertex2f(int x, int y) { - gl.glVertex2f(x, y); - } - - public void glEnable(int gl_alpha_test2) { - gl.glEnable(gl_alpha_test2); - } - - public void glColor3ub(byte b, byte c, byte d) { - gl.glColor3ub(b, c, d); - } - - public void glColor4f(int i, int j, int k, float f) { - gl.glColor4f(i, j, k, f); - } - - public void glTexImage2D(int gl_texture_2d2, int i, int gl_tex_solid_format, int j, int k, int l, int gl_rgba3, int gl_unsigned_byte2, IntBuffer image32) { - gl.glTexImage2D(gl_texture_2d2, i, gl_tex_solid_format, j, k, l, gl_rgba3, gl_unsigned_byte2, image32); - } - - public void glTexImage2D(int gl_texture_2d2, int i, int gl_color_index8_ext, int j, int k, int l, int gl_color_index2, int gl_unsigned_byte2, ByteBuffer image8) { - gl.glTexImage2D(gl_texture_2d2, i, gl_color_index8_ext, j, k, l, gl_color_index2, gl_unsigned_byte2, image8); - } - - public void glColor4ub(byte b, byte c, byte d, byte e) { - gl.glColor4ub(b, c, d, e); - } - - public void glTexParameteri(int gl_texture_2d2, int gl_texture_min_filter2, int gl_filter_min) { - gl.glTexParameteri(gl_texture_2d2, gl_texture_min_filter2, gl_filter_min); - } - - public void glTexSubImage2D(int gl_texture_2d2, int i, int j, int k, int lm_block_width, int height, int gl_lightmap_format, int gl_unsigned_byte2, IntBuffer lightmap_buffer) { - gl.glTexSubImage2D(gl_texture_2d2, i, j, k, lm_block_width, height, gl_lightmap_format, gl_unsigned_byte2, lightmap_buffer); - } - - public final void glColor4f(float intens, float intens2, float intens3, float f) { - gl.glColor4f(intens, intens2, intens3, f); - } - - public final void glLoadMatrixf(float[] r_world_matrix) { - gl.glLoadMatrixf(r_world_matrix); - } - - public final void glInterleavedArrays(int gl_t2f_v3f2, int byte_stride, FloatBuffer globalPolygonInterleavedBuf) { - gl.glInterleavedArrays(gl_t2f_v3f2, byte_stride, globalPolygonInterleavedBuf); - } - - public final void glDrawElements(int mode, int count, int gl_unsigned_int2, IntBuffer srcIndexBuf) { - gl.glDrawElements(mode, count, gl_unsigned_int2, srcIndexBuf); - } - - public final void glDisableClientState(int gl_color_array2) { - gl.glDisableClientState(gl_color_array2); - } - - public final void glVertexPointer(int i, int gl_float2, int j, FloatBuffer vertexArrayBuf) { - gl.glVertexPointer(i, gl_float2, j, vertexArrayBuf); - } - - public final void glEnableClientState(int gl_color_array2) { - gl.glEnableClientState(gl_color_array2); - } - - public final void glColorPointer(int i, int gl_float2, int j, FloatBuffer colorArrayBuf) { - gl.glColorPointer(i, gl_float2, j, colorArrayBuf); - } - - public final void glTexCoordPointer(int i, int gl_float2, int j, FloatBuffer textureArrayBuf) { - gl.glTexCoordPointer(i, gl_float2, j, textureArrayBuf); - } - - public final void glDepthRange(float gldepthmin, double d) { - gl.glDepthRange(gldepthmin, d); - } - - public final void glMatrixMode(int gl_projection2) { - gl.glMatrixMode(gl_projection2); - } - - public final void glLoadIdentity() { - gl.glLoadIdentity(); - } - - public final void glScalef(int i, int j, int k) { - gl.glScalef(i, j, k); - } - - public final void glCullFace(int gl_back2) { - gl.glCullFace(gl_back2); - } - - public final void glClear(int gl_color_buffer_bit2) { - gl.glClear(gl_color_buffer_bit2); - } - - public final void glDepthFunc(int gl_lequal2) { - gl.glDepthFunc(gl_lequal2); - } - - public final void glFrustum(double xmin, double xmax, double ymin, double ymax, double near, double far) { - gl.glFrustum(xmin, xmax, ymin, ymax, near, far); - } - - public final void glViewport(int i, int j, int width, int height) { - gl.glViewport(i, j, width, height); - } - - public final void glOrtho(int i, int width, int height, int j, int k, int l) { - gl.glOrtho(i, width, height, j, k, l); - } - - public void glColorPointer(int i, int gl_unsigned_byte2, int j, ByteBuffer bb) { - gl.glColorPointer(i, gl_unsigned_byte2, j, bb.asIntBuffer()); - } - - public void glPointSize(float value) { - gl.glPointSize(value); - } - - public void glClearColor(float f, float g, float h, float i) { - gl.glClearColor(f, g, h, i); - } -} diff --git a/src/jake2/render/fastjogl/Image.java b/src/jake2/render/fastjogl/Image.java deleted file mode 100644 index 007c154..0000000 --- a/src/jake2/render/fastjogl/Image.java +++ /dev/null @@ -1,371 +0,0 @@ -/* - * Image.java - * Copyright (C) 2003 - * - * $Id: Image.java,v 1.9 2006-10-31 13:06:32 salomo 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.fastjogl; - -import jake2.Defines; -import jake2.client.VID; -import jake2.client.particle_t; -import jake2.game.cvar_t; -import jake2.qcommon.*; -import jake2.render.image_t; -import jake2.render.common.Image.glmode_t; -import jake2.render.common.Image.gltmode_t; -import jake2.util.Lib; -import jake2.util.Vargs; - -import java.awt.Dimension; -import java.nio.*; -import java.util.Arrays; - -import net.java.games.jogl.GL; - -/** - * Image - * - * @author cwei - */ -public abstract class Image extends Main { - - protected void GlutWireCube() { - glut.glutWireCube(gl, 20); - } - - protected void GL_GetWorldMatrix() { - gl.glGetFloatv(GL.GL_MODELVIEW_MATRIX, r_world_matrix); - } - - protected void GL_LoadMatrix() - { - gl.glLoadMatrixf(r_world_matrix); - } - - protected void GL_SetTexturePalette(int[] palette) { - - assert (palette != null && palette.length == 256) : "int palette[256] bug"; - - int i; - byte[] temptable = new byte[768]; - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f) { - for (i = 0; i < 256; i++) { - temptable[i * 3 + 0] = (byte) ((palette[i] >> 0) & 0xff); - temptable[i * 3 + 1] = (byte) ((palette[i] >> 8) & 0xff); - temptable[i * 3 + 2] = (byte) ((palette[i] >> 16) & 0xff); - } - - gl.glColorTableEXT(GL.GL_SHARED_TEXTURE_PALETTE_EXT, GL.GL_RGB, - 256, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, temptable); - } - } - - - /* - * ================================================== - * - * PCX LOADING - * - * ================================================== - */ - - int[] scaled = new int[256 * 256]; - - byte[] paletted_texture = new byte[256 * 256]; - - IntBuffer tex = Lib.newIntBuffer(512 * 256, ByteOrder.LITTLE_ENDIAN); - - /* - * GL_Upload32 - * - * Returns has_alpha - */ - protected boolean GL_Upload32(int[] data, int width, int height, - boolean mipmap) { - int samples; - int scaled_width, scaled_height; - int i, c; - int comp; - - Arrays.fill(scaled, 0); - Arrays.fill(paletted_texture, (byte) 0); - - uploaded_paletted = false; - - for (scaled_width = 1; scaled_width < width; scaled_width <<= 1) - ; - if (gl_round_down.value > 0.0f && scaled_width > width && mipmap) - scaled_width >>= 1; - for (scaled_height = 1; scaled_height < height; scaled_height <<= 1) - ; - if (gl_round_down.value > 0.0f && scaled_height > height && mipmap) - scaled_height >>= 1; - - // let people sample down the world textures for speed - if (mipmap) { - scaled_width >>= (int) gl_picmip.value; - scaled_height >>= (int) gl_picmip.value; - } - - // don't ever bother with >256 textures - if (scaled_width > 256) - scaled_width = 256; - if (scaled_height > 256) - scaled_height = 256; - - if (scaled_width < 1) - scaled_width = 1; - if (scaled_height < 1) - scaled_height = 1; - - upload_width = scaled_width; - upload_height = scaled_height; - - if (scaled_width * scaled_height > 256 * 256) - Com.Error(Defines.ERR_DROP, "GL_Upload32: too big"); - - // scan the texture for any non-255 alpha - c = width * height; - samples = gl_solid_format; - - for (i = 0; i < c; i++) { - if ((data[i] & 0xff000000) != 0xff000000) { - samples = gl_alpha_format; - break; - } - } - - if (samples == gl_solid_format) - comp = gl_tex_solid_format; - else if (samples == gl_alpha_format) - comp = gl_tex_alpha_format; - else { - VID.Printf(Defines.PRINT_ALL, - "Unknown number of texture components " + samples + '\n'); - comp = samples; - } - - // simulates a goto - try { - if (scaled_width == width && scaled_height == height) { - if (!mipmap) { - if (qglColorTableEXT - && gl_ext_palettedtexture.value != 0.0f - && samples == gl_solid_format) { - uploaded_paletted = true; - GL_BuildPalettedTexture(paletted_texture, data, - scaled_width, scaled_height); - gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, - GL_COLOR_INDEX8_EXT, scaled_width, - scaled_height, 0, GL.GL_COLOR_INDEX, - GL.GL_UNSIGNED_BYTE, paletted_texture); - } else { - tex.rewind(); - tex.put(data, 0, scaled_width * scaled_height); - gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, comp, - scaled_width, scaled_height, 0, GL.GL_RGBA, - GL.GL_UNSIGNED_BYTE, tex); - } - // goto done; - throw new longjmpException(); - } - System.arraycopy(data, 0, scaled, 0, scaled_width * scaled_height); - } else - GL_ResampleTexture(data, width, height, scaled, scaled_width, scaled_height); - - GL_LightScaleTexture(scaled, scaled_width, scaled_height, !mipmap); - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f - && (samples == gl_solid_format)) { - uploaded_paletted = true; - GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, - scaled_height); - gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, - scaled_width, scaled_height, 0, GL.GL_COLOR_INDEX, - GL.GL_UNSIGNED_BYTE, paletted_texture); - } else { - tex.rewind(); - tex.put(scaled, 0, scaled_width * scaled_height); - gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, comp, scaled_width, - scaled_height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, tex); - } - - if (mipmap) { - int miplevel; - miplevel = 0; - while (scaled_width > 1 || scaled_height > 1) { - GL_MipMap(scaled, scaled_width, scaled_height); - scaled_width >>= 1; - scaled_height >>= 1; - if (scaled_width < 1) - scaled_width = 1; - if (scaled_height < 1) - scaled_height = 1; - - miplevel++; - if (qglColorTableEXT - && gl_ext_palettedtexture.value != 0.0f - && samples == gl_solid_format) { - uploaded_paletted = true; - GL_BuildPalettedTexture(paletted_texture, scaled, - scaled_width, scaled_height); - gl.glTexImage2D(GL.GL_TEXTURE_2D, miplevel, - GL_COLOR_INDEX8_EXT, scaled_width, - scaled_height, 0, GL.GL_COLOR_INDEX, - GL.GL_UNSIGNED_BYTE, paletted_texture); - } else { - tex.rewind(); - tex.put(scaled, 0, scaled_width * scaled_height); - gl.glTexImage2D(GL.GL_TEXTURE_2D, miplevel, comp, - scaled_width, scaled_height, 0, GL.GL_RGBA, - GL.GL_UNSIGNED_BYTE, tex); - } - } - } - // label done: - } catch (longjmpException e) { - // replaces label done - } - - if (mipmap) { - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, - gl_filter_min); - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, - gl_filter_max); - } else { - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, - gl_filter_max); - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, - gl_filter_max); - } - - return (samples == gl_alpha_format); - } - - int[] trans = new int[512 * 256]; - - /* - * GL_Upload8 - * - * Returns has_alpha - */ - protected boolean GL_Upload8(byte[] data, int width, int height, - boolean mipmap, boolean is_sky) { - - Arrays.fill(trans, 0); - - int s = width * height; - - if (s > trans.length) - Com.Error(Defines.ERR_DROP, "GL_Upload8: too large"); - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && is_sky) { - gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, width, - height, 0, GL.GL_COLOR_INDEX, GL.GL_UNSIGNED_BYTE, data); - - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, - gl_filter_max); - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, - gl_filter_max); - - return false; - } - - int p; - for (int i = 0; i < s; i++) { - p = data[i] & 0xff; - trans[i] = d_8to24table[p]; - - if (p == 255) { // transparent, so scan around for another - // color - // to avoid alpha fringes - // FIXME: do a full flood fill so mips work... - if (i > width && (data[i - width] & 0xff) != 255) - p = data[i - width] & 0xff; - else if (i < s - width && (data[i + width] & 0xff) != 255) - p = data[i + width] & 0xff; - else if (i > 0 && (data[i - 1] & 0xff) != 255) - p = data[i - 1] & 0xff; - else if (i < s - 1 && (data[i + 1] & 0xff) != 255) - p = data[i + 1] & 0xff; - else - p = 0; - // copy rgb components - trans[i] = d_8to24table[p] & 0x00FFFFFF; // only - // rgb - } - } - - return GL_Upload32(trans, width, height, mipmap); - - } - - /* - * GL_FreeUnusedImages - * - * Any image that was not touched on this registration sequence will be - * freed. - */ - protected void GL_FreeUnusedImages() { - // never free r_notexture or particle texture - r_notexture.registration_sequence = registration_sequence; - r_particletexture.registration_sequence = registration_sequence; - - image_t image = null; - - for (int i = 0; i < numgltextures; i++) { - image = gltextures[i]; - // used this sequence - if (image.registration_sequence == registration_sequence) - continue; - // free image_t slot - if (image.registration_sequence == 0) - continue; - // don't free pics - if (image.type == it_pic) - continue; - - // free it - gl.glDeleteTextures(1, new int[] { image.texnum }); - image.clear(); - } - } - - /* - * GL_ShutdownImages - */ - protected void GL_ShutdownImages() { - image_t image; - - for (int i = 0; i < numgltextures; i++) { - image = gltextures[i]; - - if (image.registration_sequence == 0) - continue; // free image_t slot - // free it - gl.glDeleteTextures(1, new int[] { image.texnum }); - image.clear(); - } - } -}
\ No newline at end of file diff --git a/src/jake2/render/fastjogl/Main.java b/src/jake2/render/fastjogl/Main.java deleted file mode 100644 index d90c87d..0000000 --- a/src/jake2/render/fastjogl/Main.java +++ /dev/null @@ -1,445 +0,0 @@ -/* - * Main.java - * Copyright (C) 2003 - * - * $Id: Main.java,v 1.9 2006-10-31 13:06:32 salomo 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.fastjogl; - -import jake2.Defines; -import jake2.Globals; -import jake2.client.*; -import jake2.game.*; -import jake2.qcommon.*; -import jake2.render.*; -import jake2.render.common.Base; -import jake2.render.common.Warp; -import jake2.util.Math3D; -import jake2.util.Vargs; - -import java.awt.Dimension; -import java.nio.FloatBuffer; -import java.nio.IntBuffer; - -import org.lwjgl.opengl.GL11; - -import net.java.games.jogl.GL; -import net.java.games.jogl.Version; - -/** - * Main - * - * @author cwei - */ -public abstract class Main extends JoglBase { - - /* - =============== - R_SetupFrame - =============== - */ - - protected void R_SetupFrame() { - int i; - mleaf_t leaf; - - r_framecount++; - - // build the transformation matrix for the given view angles - Math3D.VectorCopy(r_newrefdef.vieworg, r_origin); - - Math3D.AngleVectors(r_newrefdef.viewangles, vpn, vright, vup); - - // current viewcluster - if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) { - r_oldviewcluster = r_viewcluster; - r_oldviewcluster2 = r_viewcluster2; - leaf = Mod_PointInLeaf(r_origin, r_worldmodel); - r_viewcluster = r_viewcluster2 = leaf.cluster; - - // check above and below so crossing solid water doesn't draw wrong - if (leaf.contents == 0) { // look down a bit - float[] temp = { 0, 0, 0 }; - Math3D.VectorCopy(r_origin, temp); - temp[2] -= 16; - leaf = Mod_PointInLeaf(temp, r_worldmodel); - if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2)) - r_viewcluster2 = leaf.cluster; - } - else { // look up a bit - float[] temp = { 0, 0, 0 }; - Math3D.VectorCopy(r_origin, temp); - temp[2] += 16; - leaf = Mod_PointInLeaf(temp, r_worldmodel); - if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2)) - r_viewcluster2 = leaf.cluster; - } - } - - for (i = 0; i < 4; i++) - v_blend[i] = r_newrefdef.blend[i]; - - c_brush_polys = 0; - c_alias_polys = 0; - - // clear out the portion of the screen that the NOWORLDMODEL defines - if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) { - gl.glEnable(GL.GL_SCISSOR_TEST); - gl.glClearColor(0.3f, 0.3f, 0.3f, 1.0f); - gl.glScissor( - r_newrefdef.x, - vid.height - r_newrefdef.height - r_newrefdef.y, - r_newrefdef.width, - r_newrefdef.height); - gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); - gl.glClearColor(1.0f, 0.0f, 0.5f, 0.5f); - gl.glDisable(GL.GL_SCISSOR_TEST); - } - } - - - protected boolean R_Init(int vid_xpos, int vid_ypos) { - - assert (Warp.SIN.length == 256) : "warpsin table bug"; - - // fill r_turbsin - for (int j = 0; j < 256; j++) { - r_turbsin[j] = Warp.SIN[j] * 0.5f; - } - - VID.Printf(Defines.PRINT_ALL, "ref_gl version: " + Base.REF_VERSION + '\n'); - - Draw_GetPalette(); - - R_Register(); - - // set our "safe" modes - gl_state.prev_mode = 3; - - // create the window and set up the context - if (!R_SetMode()) { - VID.Printf(Defines.PRINT_ALL, - "ref_gl::R_Init() - could not R_SetMode()\n"); - return false; - } - return true; - } - - protected boolean R_Init2() { - VID.MenuInit(); - - /* - ** get our various GL strings - ** get our various GL strings - */ - VID.Printf(Defines.PRINT_ALL, "JOGL_VERSION: " + Version.getVersion() + '\n'); - gl_config.vendor_string = gl.glGetString(GL.GL_VENDOR); - VID.Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n'); - gl_config.renderer_string = gl.glGetString(GL.GL_RENDERER); - VID.Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n'); - gl_config.version_string = gl.glGetString(GL.GL_VERSION); - VID.Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n'); - gl_config.extensions_string = gl.glGetString(GL.GL_EXTENSIONS); - VID.Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n'); - - gl_config.parseOpenGLVersion(); - - String renderer_buffer = gl_config.renderer_string.toLowerCase(); - String vendor_buffer = gl_config.vendor_string.toLowerCase(); - - if (renderer_buffer.indexOf("voodoo") >= 0) { - if (renderer_buffer.indexOf("rush") < 0) - gl_config.renderer = Base.GL_RENDERER_VOODOO; - else - gl_config.renderer = Base.GL_RENDERER_VOODOO_RUSH; - } else if (vendor_buffer.indexOf("sgi") >= 0) - gl_config.renderer = Base.GL_RENDERER_SGI; - else if (renderer_buffer.indexOf("permedia") >= 0) - gl_config.renderer = Base.GL_RENDERER_PERMEDIA2; - else if (renderer_buffer.indexOf("glint") >= 0) - gl_config.renderer = Base.GL_RENDERER_GLINT_MX; - else if (renderer_buffer.indexOf("glzicd") >= 0) - gl_config.renderer = Base.GL_RENDERER_REALIZM; - else if (renderer_buffer.indexOf("gdi") >= 0) - gl_config.renderer = Base.GL_RENDERER_MCD; - else if (renderer_buffer.indexOf("pcx2") >= 0) - gl_config.renderer = Base.GL_RENDERER_PCX2; - else if (renderer_buffer.indexOf("verite") >= 0) - gl_config.renderer = Base.GL_RENDERER_RENDITION; - else - gl_config.renderer = Base.GL_RENDERER_OTHER; - - String monolightmap = gl_monolightmap.string.toUpperCase(); - if (monolightmap.length() < 2 || monolightmap.charAt(1) != 'F') { - if (gl_config.renderer == Base.GL_RENDERER_PERMEDIA2) { - Cvar.Set("gl_monolightmap", "A"); - VID.Printf(Defines.PRINT_ALL, "...using gl_monolightmap 'a'\n"); - } - else if ((gl_config.renderer & Base.GL_RENDERER_POWERVR) != 0) { - Cvar.Set("gl_monolightmap", "0"); - } - else { - Cvar.Set("gl_monolightmap", "0"); - } - } - - // power vr can't have anything stay in the framebuffer, so - // the screen needs to redraw the tiled background every frame - if ((gl_config.renderer & Base.GL_RENDERER_POWERVR) != 0) { - Cvar.Set("scr_drawall", "1"); - } - else { - Cvar.Set("scr_drawall", "0"); - } - - // MCD has buffering issues - if (gl_config.renderer == Base.GL_RENDERER_MCD) { - Cvar.SetValue("gl_finish", 1); - } - - if ((gl_config.renderer & Base.GL_RENDERER_3DLABS) != 0) { - if (gl_3dlabs_broken.value != 0.0f) - gl_config.allow_cds = false; - else - gl_config.allow_cds = true; - } - else { - gl_config.allow_cds = true; - } - - if (gl_config.allow_cds) - VID.Printf(Defines.PRINT_ALL, "...allowing CDS\n"); - else - VID.Printf(Defines.PRINT_ALL, "...disabling CDS\n"); - - /* - ** grab extensions - */ - if (gl_config.extensions_string.indexOf("GL_EXT_compiled_vertex_array") >= 0 - || gl_config.extensions_string.indexOf("GL_SGI_compiled_vertex_array") >= 0) { - VID.Printf(Defines.PRINT_ALL, "...enabling GL_EXT_compiled_vertex_array\n"); - // qglLockArraysEXT = ( void * ) qwglGetProcAddress( "glLockArraysEXT" ); - if (gl_ext_compiled_vertex_array.value != 0.0f) - qglLockArraysEXT = true; - else - qglLockArraysEXT = false; - // qglUnlockArraysEXT = ( void * ) qwglGetProcAddress( "glUnlockArraysEXT" ); - //qglUnlockArraysEXT = true; - } - else { - VID.Printf(Defines.PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n"); - qglLockArraysEXT = false; - } - - if (gl_config.extensions_string.indexOf("WGL_EXT_swap_control") >= 0) { - qwglSwapIntervalEXT = true; - VID.Printf(Defines.PRINT_ALL, "...enabling WGL_EXT_swap_control\n"); - } else { - qwglSwapIntervalEXT = false; - VID.Printf(Defines.PRINT_ALL, "...WGL_EXT_swap_control not found\n"); - } - - if (gl_config.extensions_string.indexOf("GL_EXT_point_parameters") >= 0) { - if (gl_ext_pointparameters.value != 0.0f) { - // qglPointParameterfEXT = ( void (APIENTRY *)( GLenum, GLfloat ) ) qwglGetProcAddress( "glPointParameterfEXT" ); - qglPointParameterfEXT = true; - // qglPointParameterfvEXT = ( void (APIENTRY *)( GLenum, const GLfloat * ) ) qwglGetProcAddress( "glPointParameterfvEXT" ); - VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_point_parameters\n"); - } - else { - VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_point_parameters\n"); - } - } - else { - VID.Printf(Defines.PRINT_ALL, "...GL_EXT_point_parameters not found\n"); - } - - // #ifdef __linux__ - // if ( strstr( gl_config.extensions_string, "3DFX_set_global_palette" )) - // { - // if ( gl_ext_palettedtexture->value ) - // { - // VID.Printf( Defines.PRINT_ALL, "...using 3DFX_set_global_palette\n" ); - // qgl3DfxSetPaletteEXT = ( void ( APIENTRY * ) (GLuint *) )qwglGetProcAddress( "gl3DfxSetPaletteEXT" ); - //// qglColorTableEXT = Fake_glColorTableEXT; - // } - // else - // { - // VID.Printf( Defines.PRINT_ALL, "...ignoring 3DFX_set_global_palette\n" ); - // } - // } - // else - // { - // VID.Printf( Defines.PRINT_ALL, "...3DFX_set_global_palette not found\n" ); - // } - // #endif - - if (!qglColorTableEXT - && gl_config.extensions_string.indexOf("GL_EXT_paletted_texture") >= 0 - && gl_config.extensions_string.indexOf("GL_EXT_shared_texture_palette") >= 0) { - if (gl_ext_palettedtexture.value != 0.0f) { - VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_shared_texture_palette\n"); - qglColorTableEXT = false; // true; TODO jogl bug - } - else { - VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_shared_texture_palette\n"); - qglColorTableEXT = false; - } - } - else { - VID.Printf(Defines.PRINT_ALL, "...GL_EXT_shared_texture_palette not found\n"); - } - - if (gl_config.extensions_string.indexOf("GL_ARB_multitexture") >= 0) { - VID.Printf(Defines.PRINT_ALL, "...using GL_ARB_multitexture\n"); - qglActiveTextureARB = true; - GL_TEXTURE0 = GL.GL_TEXTURE0_ARB; - GL_TEXTURE1 = GL.GL_TEXTURE1_ARB; - } - else { - VID.Printf(Defines.PRINT_ALL, "...GL_ARB_multitexture not found\n"); - } - - if (!(qglActiveTextureARB)) - return false; - - GL_SetDefaultState(); - - GL_InitImages(); - Mod_Init(); - R_InitParticleTexture(); - Draw_InitLocal(); - - int err = gl.glGetError(); - if (err != GL.GL_NO_ERROR) - VID.Printf( - Defines.PRINT_ALL, - "glGetError() = 0x%x\n\t%s\n", - new Vargs(2).add(err).add("" + gl.glGetString(err))); - - return true; - } - - /* - @@@@@@@@@@@@@@@@@@@@@ - R_BeginFrame - @@@@@@@@@@@@@@@@@@@@@ - */ - protected void R_BeginFrame(float camera_separation) { - - gl_state.camera_separation = camera_separation; - - /* - ** change modes if necessary - */ - if (gl_mode.modified || vid_fullscreen.modified) { - // FIXME: only restart if CDS is required - cvar_t ref; - - ref = Cvar.Get("vid_ref", "fastjogl", 0); - ref.modified = true; - } - - if (gl_log.modified) { - GLimp_EnableLogging((gl_log.value != 0.0f)); - gl_log.modified = false; - } - - if (gl_log.value != 0.0f) { - GLimp_LogNewFrame(); - } - - /* - ** update 3Dfx gamma -- it is expected that a user will do a vid_restart - ** after tweaking this value - */ - if (vid_gamma.modified) { - vid_gamma.modified = false; - - if ((gl_config.renderer & Base.GL_RENDERER_VOODOO) != 0) { - - VID.Printf(Defines.PRINT_DEVELOPER, - "gamma anpassung fuer VOODOO nicht gesetzt"); - } - } - - GLimp_BeginFrame(camera_separation); - - /* - ** go into 2D mode - */ - gl.glViewport(0, 0, vid.width, vid.height); - gl.glMatrixMode(GL.GL_PROJECTION); - gl.glLoadIdentity(); - gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999); - gl.glMatrixMode(GL.GL_MODELVIEW); - gl.glLoadIdentity(); - gl.glDisable(GL.GL_DEPTH_TEST); - gl.glDisable(GL.GL_CULL_FACE); - gl.glDisable(GL.GL_BLEND); - gl.glEnable(GL.GL_ALPHA_TEST); - gl.glColor4f(1, 1, 1, 1); - - /* - ** draw buffer stuff - */ - if (gl_drawbuffer.modified) { - gl_drawbuffer.modified = false; - - if (gl_state.camera_separation == 0 || !gl_state.stereo_enabled) { - if (gl_drawbuffer.string.equalsIgnoreCase("GL_FRONT")) - gl.glDrawBuffer(GL.GL_FRONT); - else - gl.glDrawBuffer(GL.GL_BACK); - } - } - - /* - ** texturemode stuff - */ - if (gl_texturemode.modified) { - GL_TextureMode(gl_texturemode.string); - gl_texturemode.modified = false; - } - - if (gl_texturealphamode.modified) { - GL_TextureAlphaMode(gl_texturealphamode.string); - gl_texturealphamode.modified = false; - } - - if (gl_texturesolidmode.modified) { - GL_TextureSolidMode(gl_texturesolidmode.string); - gl_texturesolidmode.modified = false; - } - - /* - ** swapinterval stuff - */ - GL_UpdateSwapInterval(); - - // - // clear screen if desired - // - R_Clear(); - } - -} diff --git a/src/jake2/render/fastjogl/Misc.java b/src/jake2/render/fastjogl/Misc.java deleted file mode 100644 index f6df9c6..0000000 --- a/src/jake2/render/fastjogl/Misc.java +++ /dev/null @@ -1,225 +0,0 @@ -/* - * Misc.java - * Copyright (C) 2003 - * - * $Id: Misc.java,v 1.8 2006-10-31 13:06:32 salomo 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.fastjogl; - -import jake2.Defines; -import jake2.client.VID; -import jake2.qcommon.FS; -import jake2.qcommon.xcommand_t; -import jake2.render.common.Base; - -import java.io.*; -import java.nio.ByteBuffer; -import java.nio.MappedByteBuffer; -import java.nio.channels.FileChannel; - -import net.java.games.jogl.GL; -import net.java.games.jogl.WGL; - -/** - * Misc - * - * @author cwei - */ -public abstract class Misc extends Image { - - // /* - // ============================================================================== - // - // SCREEN SHOTS - // - // ============================================================================== - // */ - // - // typedef struct _TargaHeader { - // unsigned char id_length, colormap_type, image_type; - // unsigned short colormap_index, colormap_length; - // unsigned char colormap_size; - // unsigned short x_origin, y_origin, width, height; - // unsigned char pixel_size, attributes; - // } TargaHeader; - - private final static int TGA_HEADER_SIZE = 18; - - /** - * GL_ScreenShot_f - */ - protected void GL_ScreenShot_f() { - if (contextInUse) { - screenshot_f(); - } else { - updateScreen(screenshotCall); - } - } - - private xcommand_t screenshotCall = new xcommand_t() { - public void execute() { - screenshot_f(); - } - }; - - private void screenshot_f() { - StringBuffer sb = new StringBuffer(FS.Gamedir() + "/scrshot/jake00.tga"); - FS.CreatePath(sb.toString()); - File file = new File(sb.toString()); - // find a valid file name - int i = 0; int offset = sb.length() - 6; - while (file.exists() && i++ < 100) { - sb.setCharAt(offset, (char) ((i/10) + '0')); - sb.setCharAt(offset + 1, (char) ((i%10) + '0')); - file = new File(sb.toString()); - } - if (i == 100) { - VID.Printf(Defines.PRINT_ALL, "Clean up your screenshots\n"); - return; - } - - try { - RandomAccessFile out = new RandomAccessFile(file, "rw"); - FileChannel ch = out.getChannel(); - int fileLength = TGA_HEADER_SIZE + vid.width * vid.height * 3; - out.setLength(fileLength); - MappedByteBuffer image = ch.map(FileChannel.MapMode.READ_WRITE, 0, - fileLength); - - // write the TGA header - image.put(0, (byte) 0).put(1, (byte) 0); - image.put(2, (byte) 2); // uncompressed type - image.put(12, (byte) (vid.width & 0xFF)); // vid.width - image.put(13, (byte) (vid.width >> 8)); // vid.width - image.put(14, (byte) (vid.height & 0xFF)); // vid.height - image.put(15, (byte) (vid.height >> 8)); // vid.height - image.put(16, (byte) 24); // pixel size - - // go to image data position - image.position(TGA_HEADER_SIZE); - // jogl needs a sliced buffer - ByteBuffer rgb = image.slice(); - - // change pixel alignment for reading - if (vid.width % 4 != 0) { - gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1); - } - - // OpenGL 1.2+ supports the GL_BGR color format - // check the GL_VERSION to use the TARGA BGR order if possible - // e.g.: 1.5.2 NVIDIA 66.29 - if (gl_config.getOpenGLVersion() >= 1.2f) { - // read the BGR values into the image buffer - gl.glReadPixels(0, 0, vid.width, vid.height, GL.GL_BGR, GL.GL_UNSIGNED_BYTE, rgb); - } else { - // read the RGB values into the image buffer - gl.glReadPixels(0, 0, vid.width, vid.height, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, rgb); - // flip RGB to BGR - byte tmp; - for (i = TGA_HEADER_SIZE; i < fileLength; i += 3) { - tmp = image.get(i); - image.put(i, image.get(i + 2)); - image.put(i + 2, tmp); - } - } - // reset to default alignment - gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 4); - // close the file channel - ch.close(); - } catch (IOException e) { - VID.Printf(Defines.PRINT_ALL, e.getMessage() + '\n'); - } - - VID.Printf(Defines.PRINT_ALL, "Wrote " + file + '\n'); - } - - /* - ** GL_SetDefaultState - */ - protected void GL_SetDefaultState() { - gl.glClearColor(1f, 0f, 0.5f, 0.5f); // original quake2 - //gl.glClearColor(0, 0, 0, 0); // replaced with black - gl.glCullFace(GL.GL_FRONT); - gl.glEnable(GL.GL_TEXTURE_2D); - - gl.glEnable(GL.GL_ALPHA_TEST); - gl.glAlphaFunc(GL.GL_GREATER, 0.666f); - - gl.glDisable(GL.GL_DEPTH_TEST); - gl.glDisable(GL.GL_CULL_FACE); - gl.glDisable(GL.GL_BLEND); - - gl.glColor4f(1, 1, 1, 1); - - gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL); - gl.glShadeModel(GL.GL_FLAT); - - GL_TextureMode(gl_texturemode.string); - GL_TextureAlphaMode(gl_texturealphamode.string); - GL_TextureSolidMode(gl_texturesolidmode.string); - - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, gl_filter_min); - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, gl_filter_max); - - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT); - gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT); - - gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); - - GL_TexEnv(GL.GL_REPLACE); - - if (qglPointParameterfEXT) { - float[] attenuations = { gl_particle_att_a.value, gl_particle_att_b.value, gl_particle_att_c.value }; - - gl.glEnable(GL.GL_POINT_SMOOTH); - gl.glPointParameterfEXT(GL.GL_POINT_SIZE_MIN_EXT, gl_particle_min_size.value); - gl.glPointParameterfEXT(GL.GL_POINT_SIZE_MAX_EXT, gl_particle_max_size.value); - gl.glPointParameterfvEXT(GL.GL_DISTANCE_ATTENUATION_EXT, attenuations); - } - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f) { - gl.glEnable(GL.GL_SHARED_TEXTURE_PALETTE_EXT); - - GL_SetTexturePalette(d_8to24table); - } - - GL_UpdateSwapInterval(); - - /* - * vertex array extension - */ - gl.glEnableClientState(GL.GL_VERTEX_ARRAY); - gl.glClientActiveTextureARB(GL_TEXTURE0); - gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY); - } - - protected void GL_UpdateSwapInterval() { - if (gl_swapinterval.modified) { - gl_swapinterval.modified = false; - if (!gl_state.stereo_enabled) { - if (qwglSwapIntervalEXT) { - ((WGL) gl).wglSwapIntervalEXT((int) gl_swapinterval.value); - } - } - } - } -} diff --git a/src/jake2/render/glconfig_t.java b/src/jake2/render/glconfig_t.java index 8e4f49c..075dab9 100644 --- a/src/jake2/render/glconfig_t.java +++ b/src/jake2/render/glconfig_t.java @@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ // Created on 20.11.2003 by RST. -// $Id: glconfig_t.java,v 1.2 2005-05-07 18:23:26 cawe Exp $ +// $Id: glconfig_t.java,v 1.3 2006-11-21 00:51:22 cawe Exp $ package jake2.render; @@ -36,7 +36,11 @@ public class glconfig_t { private float version = 1.1f; public void parseOpenGLVersion() { - version = Float.parseFloat(version_string.substring(0, 3)); + try { + version = Float.parseFloat(version_string.substring(0, 3)); + } catch (Exception e) { + version = 1.1f; + } } public float getOpenGLVersion() { diff --git a/src/jake2/render/lwjgl/GLWrapLWJGL.java b/src/jake2/render/lwjgl/GLWrapLWJGL.java deleted file mode 100644 index 4a878ff..0000000 --- a/src/jake2/render/lwjgl/GLWrapLWJGL.java +++ /dev/null @@ -1,250 +0,0 @@ -/* -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. - -*/ - -// Created on 28.10.2006 by RST. -// $Id: GLWrapLWJGL.java,v 1.1 2006-10-31 13:06:33 salomo Exp $ - -package jake2.render.lwjgl; - - -import java.nio.*; - -import org.lwjgl.opengl.GL11; -import org.lwjgl.util.GLImpl; - -import net.java.games.jogl.GL; -import jake2.*; -import jake2.client.*; -import jake2.game.*; -import jake2.qcommon.*; -import jake2.render.*; -import jake2.render.common.GenericGL; -import jake2.server.*; -import net.java.games.jogl.*; - -public class GLWrapLWJGL implements GenericGL{ - - protected GLImpl gl; - - public GLWrapLWJGL(GLImpl gl) - { - this.gl = gl; - } - - public final void glTexParameterf(int gl_texture_2d, int gl_texture_min_filter, int gl_nearest) { - gl.glTexParameterf(gl_texture_2d, gl_texture_min_filter, gl_nearest); - } - - public final void glBegin(int gl_triangle_fan2) { - gl.glBegin(gl_triangle_fan2); - } - - public final void glTexCoord2f(float s, float t) { - gl.glTexCoord2f(s, t); - } - - public final void glVertex3f(float f, float g, float h) { - gl.glVertex3f(f, g, h); - } - - public final void glEnd() { - gl.glEnd(); - } - - public final void glPushMatrix() { - gl.glPushMatrix(); - } - - public final void glTranslatef(float f, float g, float h) { - gl.glTranslatef(f, g, h); - } - - public final void glRotatef(float f, float g, float h, float i) { - gl.glRotatef(f, g, h, i); - } - - public final void glPopMatrix() { - gl.glPopMatrix(); - } - - public final void glColor3f(float f, float g, float h) { - gl.glColor3f(f, g, h); - } - - public final void glDepthMask(boolean b) { - gl.glDepthMask(b); - } - - public final void glDisable(int gl_texture_2d2) { - gl.glDisable(gl_texture_2d2); - } - - public final void glBlendFunc(int gl_src_alpha2, int gl_one_minus_src_alpha2) { - gl.glBlendFunc(gl_src_alpha2, gl_one_minus_src_alpha2); - } - - public final void glShadeModel(int gl_smooth2) { - gl.glShadeModel(gl_smooth2); - } - - public final void glDrawArrays(int gl_polygon2, int pos, int numverts) { - gl.glDrawArrays(gl_polygon2, pos, numverts); - } - - public final void glBindTexture(int gl_texture_2d2, int texnum) { - gl.glBindTexture(gl_texture_2d2, texnum); - } - - public final void glActiveTextureARB(int texture) { - gl.glActiveTextureARB( texture); - } - - public final void glClientActiveTextureARB(int texture) { - gl.glClientActiveTextureARB(texture); - } - - public final void glTexEnvi(int gl_texture_env2, int gl_texture_env_mode2, int mode) { - gl.glTexEnvi(gl_texture_env2, gl_texture_env_mode2, mode); - } - - public final void glVertex2f(int x, int y) { - gl.glVertex2f(x, y); - } - - public final void glEnable(int gl_alpha_test2) { - gl.glEnable(gl_alpha_test2); - } - - public final void glColor3ub(byte b, byte c, byte d) { - gl.glColor3ub(b, c, d); - } - - public final void glColor4f(int i, int j, int k, float f) { - gl.glColor4f(i, j, k, f); - } - - public final void glTexImage2D(int gl_texture_2d2, int i, int gl_tex_solid_format, int j, int k, int l, int gl_rgba3, int gl_unsigned_byte2, IntBuffer image32) { - gl.glTexImage2D(gl_texture_2d2, i, gl_tex_solid_format, j, k, l, gl_rgba3, gl_unsigned_byte2, image32); - } - - public final void glTexImage2D(int gl_texture_2d2, int i, int gl_color_index8_ext, int j, int k, int l, int gl_color_index2, int gl_unsigned_byte2, ByteBuffer image8) { - gl.glTexImage2D(gl_texture_2d2, i, gl_color_index8_ext, j, k, l, gl_color_index2, gl_unsigned_byte2, image8); - } - - public final void glColor4ub(byte b, byte c, byte d, byte e) { - gl.glColor4ub(b, c, d, e); - } - - public final void glTexParameteri(int gl_texture_2d2, int gl_texture_min_filter2, int gl_filter_min) { - gl.glTexParameteri(gl_texture_2d2, gl_texture_min_filter2, gl_filter_min); - } - - public final void glTexSubImage2D(int gl_texture_2d2, int i, int j, int k, int lm_block_width, int height, int gl_lightmap_format, int gl_unsigned_byte2, IntBuffer lightmap_buffer) { - gl.glTexSubImage2D(gl_texture_2d2, i, j, k, lm_block_width, height, gl_lightmap_format, gl_unsigned_byte2, lightmap_buffer); - } - - public final void glColor4f(float intens, float intens2, float intens3, float f) { - gl.glColor4f(intens, intens2, intens3, f); - } - - public final void glLoadMatrixf(float[] r_world_matrix) { - gl.glLoadMatrix(FloatBuffer.wrap(r_world_matrix)); - } - - public final void glInterleavedArrays(int gl_t2f_v3f2, int byte_stride, FloatBuffer globalPolygonInterleavedBuf) { - gl.glInterleavedArrays(gl_t2f_v3f2, byte_stride, globalPolygonInterleavedBuf); - } - - public void glDrawElements(int mode, int count, int gl_unsigned_int2, IntBuffer srcIndexBuf) { - gl.glDrawElements(mode, srcIndexBuf); - } - - public void glDisableClientState(int gl_color_array2) { - gl.glDisableClientState(gl_color_array2); - } - - public void glVertexPointer(int i, int gl_float2, int j, FloatBuffer vertexArrayBuf) { - gl.glVertexPointer(i, j, vertexArrayBuf); - } - - public void glEnableClientState(int gl_color_array2) { - gl.glEnableClientState(gl_color_array2); - } - - public void glColorPointer(int i, int gl_float2, int j, FloatBuffer colorArrayBuf) { - gl.glColorPointer(i, j, colorArrayBuf); - } - - public final void glTexCoordPointer(int i, int gl_float2, int j, FloatBuffer textureArrayBuf) { - gl.glTexCoordPointer(i, j, textureArrayBuf); - } - - public final void glDepthRange(float gldepthmin, double d) { - gl.glDepthRange(gldepthmin, d); - } - - public final void glMatrixMode(int gl_projection2) { - gl.glMatrixMode(gl_projection2); - } - - public final void glLoadIdentity() { - gl.glLoadIdentity(); - } - - public final void glScalef(int i, int j, int k) { - gl.glScalef(i, j, k); - } - - public final void glCullFace(int gl_back2) { - gl.glCullFace(gl_back2); - } - - public final void glClear(int gl_color_buffer_bit2) { - gl.glClear(gl_color_buffer_bit2); - } - - public final void glDepthFunc(int gl_lequal2) { - gl.glDepthFunc(gl_lequal2); - } - - public final void glFrustum(double xmin, double xmax, double ymin, double ymax, double near, double far) { - gl.glFrustum(xmin, xmax, ymin, ymax, near, far); - } - - public final void glViewport(int i, int j, int width, int height) { - gl.glViewport(i, j, width, height); - } - - public final void glOrtho(int i, int width, int height, int j, int k, int l) { - gl.glOrtho(i, width, height, j, k, l); - } - - public void glColorPointer(int i, int gl_unsigned_byte2, int j, ByteBuffer bb) { - gl.glColorPointer(i, true, j, bb); - } - - public void glPointSize(float value) { - gl.glPointSize(value); - } - - public void glClearColor(float f, float g, float h, float i) { - gl.glClearColor(f, g, h, i); - } -} diff --git a/src/jake2/render/lwjgl/Image.java b/src/jake2/render/lwjgl/Image.java deleted file mode 100644 index 1bf0e40..0000000 --- a/src/jake2/render/lwjgl/Image.java +++ /dev/null @@ -1,418 +0,0 @@ -/* - * Image.java - * Copyright (C) 2003 - * - * $Id: Image.java,v 1.4 2006-10-31 13:06:33 salomo 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.lwjgl; - -import jake2.Defines; -import jake2.client.VID; -import jake2.client.particle_t; -import jake2.game.cvar_t; -import jake2.qcommon.*; -import jake2.render.image_t; -import jake2.render.common.Image.glmode_t; -import jake2.render.common.Image.gltmode_t; -import jake2.util.Lib; -import jake2.util.Vargs; - -import java.awt.Dimension; -import java.awt.geom.AffineTransform; -import java.awt.image.AffineTransformOp; -import java.awt.image.BufferedImage; -import java.nio.*; -import java.util.Arrays; - -import net.java.games.jogl.GL; - -import org.lwjgl.BufferUtils; -import org.lwjgl.opengl.EXTSharedTexturePalette; -import org.lwjgl.opengl.GL11; - -/** - * Image - * - * @author cwei - */ -public abstract class Image extends Main { - - protected void GL_GetWorldMatrix() { - gl.glGetFloat(GL11.GL_MODELVIEW_MATRIX, r_world_matrix_fb); - r_world_matrix_fb.clear(); - } - - protected void GL_LoadMatrix() { - gl.glLoadMatrix(r_world_matrix_fb); - } - - protected void GL_SetTexturePalette(int[] palette) { - - assert (palette != null && palette.length == 256) : "int palette[256] bug"; - - int i; - // byte[] temptable = new byte[768]; - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f) { - ByteBuffer temptable = BufferUtils.createByteBuffer(768); - for (i = 0; i < 256; i++) { - temptable.put(i * 3 + 0, (byte) ((palette[i] >> 0) & 0xff)); - temptable.put(i * 3 + 1, (byte) ((palette[i] >> 8) & 0xff)); - temptable.put(i * 3 + 2, (byte) ((palette[i] >> 16) & 0xff)); - } - - gl.glColorTable( - EXTSharedTexturePalette.GL_SHARED_TEXTURE_PALETTE_EXT, - GL11.GL_RGB, 256, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, - temptable); - } - } - - /** - * GL_Upload32 - * - * Returns has_alpha - */ - void GL_BuildPalettedTexture(ByteBuffer paletted_texture, int[] scaled, - int scaled_width, int scaled_height) { - - int r, g, b, c; - int size = scaled_width * scaled_height; - - for (int i = 0; i < size; i++) { - - r = (scaled[i] >> 3) & 31; - g = (scaled[i] >> 10) & 63; - b = (scaled[i] >> 19) & 31; - - c = r | (g << 5) | (b << 11); - - paletted_texture.put(i, gl_state.d_16to8table[c]); - } - } - - - /* - =============== - GL_Upload32 - - Returns has_alpha - =============== - */ - int[] scaled = new int[256 * 256]; - //byte[] paletted_texture = new byte[256 * 256]; - ByteBuffer paletted_texture=BufferUtils.createByteBuffer(256*256); - IntBuffer tex = Lib.newIntBuffer(512 * 256, ByteOrder.LITTLE_ENDIAN); - - protected boolean GL_Upload32(int[] data, int width, int height, boolean mipmap) { - int samples; - int scaled_width, scaled_height; - int i, c; - int comp; - - Arrays.fill(scaled, 0); - // Arrays.fill(paletted_texture, (byte)0); - paletted_texture.clear(); - for (int j = 0; j < 256 * 256; j++) - paletted_texture.put(j, (byte) 0); - - uploaded_paletted = false; - - for (scaled_width = 1; scaled_width < width; scaled_width <<= 1) - ; - if (gl_round_down.value > 0.0f && scaled_width > width && mipmap) - scaled_width >>= 1; - for (scaled_height = 1; scaled_height < height; scaled_height <<= 1) - ; - if (gl_round_down.value > 0.0f && scaled_height > height && mipmap) - scaled_height >>= 1; - - // let people sample down the world textures for speed - if (mipmap) { - scaled_width >>= (int) gl_picmip.value; - scaled_height >>= (int) gl_picmip.value; - } - - // don't ever bother with >256 textures - if (scaled_width > 256) - scaled_width = 256; - if (scaled_height > 256) - scaled_height = 256; - - if (scaled_width < 1) - scaled_width = 1; - if (scaled_height < 1) - scaled_height = 1; - - upload_width = scaled_width; - upload_height = scaled_height; - - if (scaled_width * scaled_height > 256 * 256) - Com.Error(Defines.ERR_DROP, "GL_Upload32: too big"); - - // scan the texture for any non-255 alpha - c = width * height; - samples = gl_solid_format; - - for (i = 0; i < c; i++) { - if ((data[i] & 0xff000000) != 0xff000000) { - samples = gl_alpha_format; - break; - } - } - - if (samples == gl_solid_format) - comp = gl_tex_solid_format; - else if (samples == gl_alpha_format) - comp = gl_tex_alpha_format; - else { - VID.Printf(Defines.PRINT_ALL, - "Unknown number of texture components " + samples + '\n'); - comp = samples; - } - - // simulates a goto - try { - if (scaled_width == width && scaled_height == height) { - if (!mipmap) { - if (qglColorTableEXT - && gl_ext_palettedtexture.value != 0.0f - && samples == gl_solid_format) { - uploaded_paletted = true; - GL_BuildPalettedTexture(paletted_texture, data, - scaled_width, scaled_height); - gl.glTexImage2D(GL11.GL_TEXTURE_2D, 0, - GL_COLOR_INDEX8_EXT, scaled_width, - scaled_height, 0, GL11.GL_COLOR_INDEX, - GL11.GL_UNSIGNED_BYTE, paletted_texture); - } else { - tex.rewind(); - tex.put(data); - tex.rewind(); - gl.glTexImage2D(GL11.GL_TEXTURE_2D, 0, comp, - scaled_width, scaled_height, 0, GL11.GL_RGBA, - GL11.GL_UNSIGNED_BYTE, tex); - } - // goto done; - throw gotoDone; - } - // memcpy (scaled, data, width*height*4); were bytes - System.arraycopy(data, 0, scaled, 0, width * height); - } else - GL_ResampleTexture(data, width, height, scaled, scaled_width, - scaled_height); - - GL_LightScaleTexture(scaled, scaled_width, scaled_height, !mipmap); - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f - && (samples == gl_solid_format)) { - uploaded_paletted = true; - GL_BuildPalettedTexture(paletted_texture, scaled, scaled_width, - scaled_height); - gl.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, - scaled_width, scaled_height, 0, GL11.GL_COLOR_INDEX, - GL11.GL_UNSIGNED_BYTE, paletted_texture); - } else { - tex.rewind(); - tex.put(scaled); - tex.rewind(); - gl.glTexImage2D(GL11.GL_TEXTURE_2D, 0, comp, scaled_width, - scaled_height, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, - tex); - } - - if (mipmap) { - int miplevel; - miplevel = 0; - while (scaled_width > 1 || scaled_height > 1) { - GL_MipMap(scaled, scaled_width, scaled_height); - scaled_width >>= 1; - scaled_height >>= 1; - if (scaled_width < 1) - scaled_width = 1; - if (scaled_height < 1) - scaled_height = 1; - - miplevel++; - if (qglColorTableEXT - && gl_ext_palettedtexture.value != 0.0f - && samples == gl_solid_format) { - uploaded_paletted = true; - GL_BuildPalettedTexture(paletted_texture, scaled, - scaled_width, scaled_height); - gl.glTexImage2D(GL11.GL_TEXTURE_2D, miplevel, - GL_COLOR_INDEX8_EXT, scaled_width, - scaled_height, 0, GL11.GL_COLOR_INDEX, - GL11.GL_UNSIGNED_BYTE, paletted_texture); - } else { - tex.rewind(); - tex.put(scaled); - tex.rewind(); - gl.glTexImage2D(GL11.GL_TEXTURE_2D, miplevel, comp, - scaled_width, scaled_height, 0, GL11.GL_RGBA, - GL11.GL_UNSIGNED_BYTE, tex); - } - } - } - // label done: - } catch (Throwable e) { - // replaces label done - } - - if (mipmap) { - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, - gl_filter_min); - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, - gl_filter_max); - } else { - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, - gl_filter_max); - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, - gl_filter_max); - } - - return (samples == gl_alpha_format); - } - - /** - * GL_Upload8 - * - * Returns has_alpha - */ - - int[] trans = new int[512 * 256]; - - protected boolean GL_Upload8(byte[] data, int width, int height, - boolean mipmap, boolean is_sky) { - - Arrays.fill(trans, 0); - - int s = width * height; - - if (s > trans.length) - Com.Error(Defines.ERR_DROP, "GL_Upload8: too large"); - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f && is_sky) { - gl.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, width, - height, 0, GL11.GL_COLOR_INDEX, GL11.GL_UNSIGNED_BYTE, - ByteBuffer.wrap(data)); - - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, - gl_filter_max); - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, - gl_filter_max); - - // TODO check this - return false; - } else { - int p; - for (int i = 0; i < s; i++) { - p = data[i] & 0xff; - trans[i] = d_8to24table[p]; - - if (p == 255) { // transparent, so scan around for another color - // to avoid alpha fringes - // FIXME: do a full flood fill so mips work... - if (i > width && (data[i - width] & 0xff) != 255) - p = data[i - width] & 0xff; - else if (i < s - width && (data[i + width] & 0xff) != 255) - p = data[i + width] & 0xff; - else if (i > 0 && (data[i - 1] & 0xff) != 255) - p = data[i - 1] & 0xff; - else if (i < s - 1 && (data[i + 1] & 0xff) != 255) - p = data[i + 1] & 0xff; - else - p = 0; - // copy rgb components - - // ((byte *)&trans[i])[0] = ((byte *)&d_8to24table[p])[0]; - // ((byte *)&trans[i])[1] = ((byte *)&d_8to24table[p])[1]; - // ((byte *)&trans[i])[2] = ((byte *)&d_8to24table[p])[2]; - - trans[i] = d_8to24table[p] & 0x00FFFFFF; // only rgb - } - } - - return GL_Upload32(trans, width, height, mipmap); - } - } - - - IntBuffer texnumBuffer = BufferUtils.createIntBuffer(1); - - /** - * GL_FreeUnusedImages - * - * Any image that was not touched on this registration sequence will be - * freed. - */ - protected void GL_FreeUnusedImages() { - - // never free r_notexture or particle texture - r_notexture.registration_sequence = registration_sequence; - r_particletexture.registration_sequence = registration_sequence; - - image_t image = null; - - for (int i = 0; i < numgltextures; i++) { - image = gltextures[i]; - // used this sequence - if (image.registration_sequence == registration_sequence) - continue; - // free image_t slot - if (image.registration_sequence == 0) - continue; - // don't free pics - if (image.type == it_pic) - continue; - - // free it - // TODO jogl bug - texnumBuffer.clear(); - texnumBuffer.put(0, image.texnum); - gl.glDeleteTextures(texnumBuffer); - image.clear(); - } - } - - - - /** - * GL_ShutdownImages. - */ - protected void GL_ShutdownImages() { - image_t image; - - for (int i = 0; i < numgltextures; i++) { - image = gltextures[i]; - - if (image.registration_sequence == 0) - continue; // free image_t slot - // free it - // TODO jogl bug - texnumBuffer.clear(); - texnumBuffer.put(0, image.texnum); - gl.glDeleteTextures(texnumBuffer); - image.clear(); - } - } -} diff --git a/src/jake2/render/lwjgl/LWJGLBase.java b/src/jake2/render/lwjgl/LWJGLBase.java deleted file mode 100644 index 7a902e5..0000000 --- a/src/jake2/render/lwjgl/LWJGLBase.java +++ /dev/null @@ -1,330 +0,0 @@ -/* - * LWJGLBase.java - * Copyright (C) 2004 - * - * $Id: LWJGLBase.java,v 1.4 2006-10-31 13:06:33 salomo 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.lwjgl; - -import jake2.Defines; -import jake2.client.VID; -import jake2.client.viddef_t; -import jake2.game.cvar_t; -import jake2.qcommon.Com; -import jake2.qcommon.xcommand_t; - -import java.awt.Dimension; -import java.util.LinkedList; - -import org.lwjgl.LWJGLException; -import org.lwjgl.opengl.*; -import org.lwjgl.util.GLImpl; - -/** - * LWJGLBase - * - * @author dsanders/cwei - */ -public abstract class LWJGLBase extends jake2.render.common.Misc { - - // IMPORTED FUNCTIONS - protected DisplayMode oldDisplayMode; - - protected GLImpl gl = new GLImpl(); - - // handles the post initialization with LWJGLRenderer - protected abstract boolean R_Init2(); - - - private java.awt.DisplayMode toAwtDisplayMode(DisplayMode m) - { - return new java.awt.DisplayMode(m.getWidth(),m.getHeight(),m.getBitsPerPixel(),m.getFrequency()); - } - - public java.awt.DisplayMode[] getModeList() - { - DisplayMode[] modes; - try { - modes = Display.getAvailableDisplayModes(); - } catch (LWJGLException e) { - Com.Println(e.getMessage()); - return new java.awt.DisplayMode[0]; - } - - LinkedList l = new LinkedList(); - l.add(toAwtDisplayMode(oldDisplayMode)); - - for (int i = 0; i < modes.length; i++) { - DisplayMode m = modes[i]; - - if (m.getBitsPerPixel() != oldDisplayMode.getBitsPerPixel()) continue; - if (m.getFrequency() > oldDisplayMode.getFrequency()) continue; - if (m.getHeight() < 240 || m.getWidth() < 320) continue; - - int j = 0; - java.awt.DisplayMode ml = null; - for (j = 0; j < l.size(); j++) { - ml = (java.awt.DisplayMode)l.get(j); - if (ml.getWidth() > m.getWidth()) break; - if (ml.getWidth() == m.getWidth() && ml.getHeight() >= m.getHeight()) break; - } - if (j == l.size()) { - l.addLast(toAwtDisplayMode(m)); - } else if (ml.getWidth() > m.getWidth() || ml.getHeight() > m.getHeight()) { - l.add(j, toAwtDisplayMode(m)); - } else if (m.getFrequency() > ml.getRefreshRate()){ - l.remove(j); - l.add(j, toAwtDisplayMode(m)); - } - } - java.awt.DisplayMode[] ma = new java.awt.DisplayMode[l.size()]; - l.toArray(ma); - return ma; - } - - public DisplayMode[] getLWJGLModeList() { - DisplayMode[] modes; - try { - modes = Display.getAvailableDisplayModes(); - } catch (LWJGLException e) { - Com.Println(e.getMessage()); - return new DisplayMode[0]; - } - - LinkedList l = new LinkedList(); - l.add(oldDisplayMode); - - for (int i = 0; i < modes.length; i++) { - DisplayMode m = modes[i]; - - if (m.getBitsPerPixel() != oldDisplayMode.getBitsPerPixel()) continue; - if (m.getFrequency() > oldDisplayMode.getFrequency()) continue; - if (m.getHeight() < 240 || m.getWidth() < 320) continue; - - int j = 0; - DisplayMode ml = null; - for (j = 0; j < l.size(); j++) { - ml = (DisplayMode)l.get(j); - if (ml.getWidth() > m.getWidth()) break; - if (ml.getWidth() == m.getWidth() && ml.getHeight() >= m.getHeight()) break; - } - if (j == l.size()) { - l.addLast(m); - } else if (ml.getWidth() > m.getWidth() || ml.getHeight() > m.getHeight()) { - l.add(j, m); - } else if (m.getFrequency() > ml.getFrequency()){ - l.remove(j); - l.add(j, m); - } - } - DisplayMode[] ma = new DisplayMode[l.size()]; - l.toArray(ma); - return ma; - } - - private DisplayMode findDisplayMode(Dimension dim) { - DisplayMode mode = null; - DisplayMode m = null; - DisplayMode[] modes = getLWJGLModeList(); - int w = dim.width; - int h = dim.height; - - for (int i = 0; i < modes.length; i++) { - m = modes[i]; - if (m.getWidth() == w && m.getHeight() == h) { - mode = m; - break; - } - } - if (mode == null) mode = oldDisplayMode; - return mode; - } - - String getModeString(DisplayMode m) { - StringBuffer sb = new StringBuffer(); - sb.append(m.getWidth()); - sb.append('x'); - sb.append(m.getHeight()); - sb.append('x'); - sb.append(m.getBitsPerPixel()); - sb.append('@'); - sb.append(m.getFrequency()); - sb.append("Hz"); - return sb.toString(); - } - - /** - * @param dim - * @param mode - * @param fullscreen - * @return enum rserr_t - */ - protected int GLimp_SetMode(Dimension dim, int mode, boolean fullscreen) { - - Dimension newDim = new Dimension(); - - VID.Printf(Defines.PRINT_ALL, "Initializing OpenGL display\n"); - - VID.Printf(Defines.PRINT_ALL, "...setting mode " + mode + ":"); - - /* - * fullscreen handling - */ - if (oldDisplayMode == null) { - oldDisplayMode = Display.getDisplayMode(); - } - - if (!VID.GetModeInfo(newDim, mode)) { - VID.Printf(Defines.PRINT_ALL, " invalid mode\n"); - return rserr_invalid_mode; - } - - VID.Printf(Defines.PRINT_ALL, " " + newDim.width + " " + newDim.height + '\n'); - - // destroy the existing window - GLimp_Shutdown(); - - Display.setTitle("Jake2"); - - DisplayMode displayMode = findDisplayMode(newDim); - newDim.width = displayMode.getWidth(); - newDim.height = displayMode.getHeight(); - - if (fullscreen) - { - try { - Display.setDisplayMode(displayMode); - } - catch (LWJGLException e) - { - return rserr_invalid_mode; - } - - Display.setLocation(0,0); - - try { - Display.setFullscreen(fullscreen); - } - catch (LWJGLException e) - { - return rserr_invalid_fullscreen; - } - - VID.Printf(Defines.PRINT_ALL, "...setting fullscreen " + getModeString(displayMode) + '\n'); - - } - else - { - try - { - Display.setDisplayMode(displayMode); - } - catch (LWJGLException e) - { - return rserr_invalid_mode; - } - - try { - Display.setFullscreen(false); - } - catch (LWJGLException e) - { - return rserr_invalid_fullscreen; - } - Display.setLocation(window_xpos, window_ypos); - } - - vid.width = newDim.width; - vid.height = newDim.height; - - try - { - Display.create(); - } - catch (LWJGLException e) - { - return rserr_unknown; - } - - // let the sound and input subsystems know about the new window - VID.NewWindow(vid.width, vid.height); - return rserr_ok; - } - - protected void GLimp_Shutdown() { - if (oldDisplayMode != null && Display.isFullscreen()) { - try { - Display.setDisplayMode(oldDisplayMode); - } catch (Exception e) { - e.printStackTrace(); - } - } - - while (Display.isCreated()) { - Display.destroy(); - } - } - - /** - * @return true - */ - protected boolean GLimp_Init(int xpos, int ypos) { - // do nothing - window_xpos = xpos; - window_ypos = ypos; - return true; - } - - protected void GLimp_EndFrame() { - gl.glFlush(); - // swap buffers - Display.update(); - } - - protected void GLimp_BeginFrame(float camera_separation) { - // do nothing - } - - protected void GLimp_AppActivate(boolean activate) { - // do nothing - } - - protected void GLimp_EnableLogging(boolean enable) { - // do nothing - } - - protected void GLimp_LogNewFrame() { - // do nothing - } - - protected void GLimp_Finish() { - gl.glFinish(); - } - - /** - * this is a hack for jogl renderers. - * @param callback - */ - public final void updateScreen(xcommand_t callback) { - callback.execute(); - } -} diff --git a/src/jake2/render/lwjgl/Main.java b/src/jake2/render/lwjgl/Main.java deleted file mode 100644 index 76774ab..0000000 --- a/src/jake2/render/lwjgl/Main.java +++ /dev/null @@ -1,472 +0,0 @@ -/* - * Main.java - * Copyright (C) 2003 - * - * $Id: Main.java,v 1.8 2006-10-31 13:06:32 salomo 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.lwjgl; - -import jake2.Defines; -import jake2.Globals; -import jake2.client.*; -import jake2.game.*; -import jake2.qcommon.*; -import jake2.render.*; -import jake2.render.common.Base; -import jake2.render.common.Warp; -import jake2.util.Math3D; -import jake2.util.Vargs; - -import java.awt.Dimension; -import java.nio.FloatBuffer; -import java.nio.IntBuffer; - -import net.java.games.jogl.GL; - -import org.lwjgl.BufferUtils; -import org.lwjgl.opengl.*; - -/** - * Main - * - * @author cwei - */ -public abstract class Main extends LWJGLBase { - - - - /* - ==================================================================== - - from gl_rmain.c - - ==================================================================== - */ - - FloatBuffer r_world_matrix_fb = BufferUtils.createFloatBuffer(16); - - // stack variable - private final float[] vtemp = { 0, 0, 0 }; - - /** - * R_SetupFrame - */ - protected void R_SetupFrame() { - r_framecount++; - - // build the transformation matrix for the given view angles - Math3D.VectorCopy(r_newrefdef.vieworg, r_origin); - - Math3D.AngleVectors(r_newrefdef.viewangles, vpn, vright, vup); - - // current viewcluster - mleaf_t leaf; - if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) == 0) { - r_oldviewcluster = r_viewcluster; - r_oldviewcluster2 = r_viewcluster2; - leaf = Mod_PointInLeaf(r_origin, r_worldmodel); - r_viewcluster = r_viewcluster2 = leaf.cluster; - - // check above and below so crossing solid water doesn't draw wrong - if (leaf.contents == 0) { // look down a bit - Math3D.VectorCopy(r_origin, vtemp); - vtemp[2] -= 16; - leaf = Mod_PointInLeaf(vtemp, r_worldmodel); - if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 && (leaf.cluster != r_viewcluster2)) - r_viewcluster2 = leaf.cluster; - } else { // look up a bit - Math3D.VectorCopy(r_origin, vtemp); - vtemp[2] += 16; - leaf = Mod_PointInLeaf(vtemp, r_worldmodel); - if ((leaf.contents & Defines.CONTENTS_SOLID) == 0 - && (leaf.cluster != r_viewcluster2)) - r_viewcluster2 = leaf.cluster; - } - } - - for (int i = 0; i < 4; i++) - v_blend[i] = r_newrefdef.blend[i]; - - c_brush_polys = 0; - c_alias_polys = 0; - - // clear out the portion of the screen that the NOWORLDMODEL defines - if ((r_newrefdef.rdflags & Defines.RDF_NOWORLDMODEL) != 0) { - gl.glEnable(GL11.GL_SCISSOR_TEST); - gl.glClearColor(0.3f, 0.3f, 0.3f, 1.0f); - gl.glScissor( - r_newrefdef.x, - vid.height - r_newrefdef.height - r_newrefdef.y, - r_newrefdef.width, - r_newrefdef.height); - gl.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT); - gl.glClearColor(1.0f, 0.0f, 0.5f, 0.5f); - gl.glDisable(GL11.GL_SCISSOR_TEST); - } - } - - - /** - * R_Init - */ - protected boolean R_Init(int vid_xpos, int vid_ypos) { - - assert (Warp.SIN.length == 256) : "warpsin table bug"; - - ggl = new GLWrapLWJGL(gl); - - GL_TEXTURE0 = GL13.GL_TEXTURE0; - GL_TEXTURE1 = GL13.GL_TEXTURE1; - - // fill r_turbsin - for (int j = 0; j < 256; j++) { - r_turbsin[j] = Warp.SIN[j] * 0.5f; - } - - VID.Printf(Defines.PRINT_ALL, "ref_gl version: " + Base.REF_VERSION + '\n'); - - Draw_GetPalette(); - - R_Register(); - - // set our "safe" modes - gl_state.prev_mode = 3; - - // create the window and set up the context - if (!R_SetMode()) { - VID.Printf(Defines.PRINT_ALL, "ref_gl::R_Init() - could not R_SetMode()\n"); - return false; - } - return true; - } - - /** - * R_Init2 - */ - protected boolean R_Init2() { - VID.MenuInit(); - - /* - ** get our various GL strings - */ - gl_config.vendor_string = gl.glGetString(GL11.GL_VENDOR); - VID.Printf(Defines.PRINT_ALL, "GL_VENDOR: " + gl_config.vendor_string + '\n'); - gl_config.renderer_string = gl.glGetString(GL11.GL_RENDERER); - VID.Printf(Defines.PRINT_ALL, "GL_RENDERER: " + gl_config.renderer_string + '\n'); - gl_config.version_string = gl.glGetString(GL11.GL_VERSION); - VID.Printf(Defines.PRINT_ALL, "GL_VERSION: " + gl_config.version_string + '\n'); - gl_config.extensions_string = gl.glGetString(GL11.GL_EXTENSIONS); - VID.Printf(Defines.PRINT_ALL, "GL_EXTENSIONS: " + gl_config.extensions_string + '\n'); - - gl_config.parseOpenGLVersion(); - - String renderer_buffer = gl_config.renderer_string.toLowerCase(); - String vendor_buffer = gl_config.vendor_string.toLowerCase(); - - if (renderer_buffer.indexOf("voodoo") >= 0) { - if (renderer_buffer.indexOf("rush") < 0) - gl_config.renderer = Base.GL_RENDERER_VOODOO; - else - gl_config.renderer = Base.GL_RENDERER_VOODOO_RUSH; - } else if (vendor_buffer.indexOf("sgi") >= 0) - gl_config.renderer = Base.GL_RENDERER_SGI; - else if (renderer_buffer.indexOf("permedia") >= 0) - gl_config.renderer = Base.GL_RENDERER_PERMEDIA2; - else if (renderer_buffer.indexOf("glint") >= 0) - gl_config.renderer = Base.GL_RENDERER_GLINT_MX; - else if (renderer_buffer.indexOf("glzicd") >= 0) - gl_config.renderer = Base.GL_RENDERER_REALIZM; - else if (renderer_buffer.indexOf("gdi") >= 0) - gl_config.renderer = Base.GL_RENDERER_MCD; - else if (renderer_buffer.indexOf("pcx2") >= 0) - gl_config.renderer = Base.GL_RENDERER_PCX2; - else if (renderer_buffer.indexOf("verite") >= 0) - gl_config.renderer = Base.GL_RENDERER_RENDITION; - else - gl_config.renderer = Base.GL_RENDERER_OTHER; - - String monolightmap = gl_monolightmap.string.toUpperCase(); - if (monolightmap.length() < 2 || monolightmap.charAt(1) != 'F') { - if (gl_config.renderer == Base.GL_RENDERER_PERMEDIA2) { - Cvar.Set("gl_monolightmap", "A"); - VID.Printf(Defines.PRINT_ALL, "...using gl_monolightmap 'a'\n"); - } - else if ((gl_config.renderer & Base.GL_RENDERER_POWERVR) != 0) { - Cvar.Set("gl_monolightmap", "0"); - } - else { - Cvar.Set("gl_monolightmap", "0"); - } - } - - // power vr can't have anything stay in the framebuffer, so - // the screen needs to redraw the tiled background every frame - if ((gl_config.renderer & Base.GL_RENDERER_POWERVR) != 0) { - Cvar.Set("scr_drawall", "1"); - } - else { - Cvar.Set("scr_drawall", "0"); - } - - // MCD has buffering issues - if (gl_config.renderer == Base.GL_RENDERER_MCD) { - Cvar.SetValue("gl_finish", 1); - } - - if ((gl_config.renderer & Base.GL_RENDERER_3DLABS) != 0) { - if (gl_3dlabs_broken.value != 0.0f) - gl_config.allow_cds = false; - else - gl_config.allow_cds = true; - } else { - gl_config.allow_cds = true; - } - - if (gl_config.allow_cds) - VID.Printf(Defines.PRINT_ALL, "...allowing CDS\n"); - else - VID.Printf(Defines.PRINT_ALL, "...disabling CDS\n"); - - /* - ** grab extensions - */ - if (gl_config.extensions_string.indexOf("GL_EXT_compiled_vertex_array") >= 0 - || gl_config.extensions_string - .indexOf("GL_SGI_compiled_vertex_array") >= 0) { - VID.Printf(Defines.PRINT_ALL, - "...enabling GL_EXT_compiled_vertex_array\n"); - // qglLockArraysEXT = ( void * ) qwglGetProcAddress( - // "glLockArraysEXT" ); - if (gl_ext_compiled_vertex_array.value != 0.0f) - qglLockArraysEXT = true; - else - qglLockArraysEXT = false; - // qglUnlockArraysEXT = ( void * ) qwglGetProcAddress( "glUnlockArraysEXT" ); - //qglUnlockArraysEXT = true; - } - else { - VID.Printf(Defines.PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n"); - qglLockArraysEXT = false; - } - - if (gl_config.extensions_string.indexOf("WGL_EXT_swap_control") >= 0) { - qwglSwapIntervalEXT = true; - VID.Printf(Defines.PRINT_ALL, "...enabling WGL_EXT_swap_control\n"); - } else { - qwglSwapIntervalEXT = false; - VID.Printf(Defines.PRINT_ALL, "...WGL_EXT_swap_control not found\n"); - } - - if (gl_config.extensions_string.indexOf("GL_EXT_point_parameters") >= 0) { - if (gl_ext_pointparameters.value != 0.0f) { - // qglPointParameterfEXT = ( void (APIENTRY *)( GLenum, GLfloat ) ) qwglGetProcAddress( "glPointParameterfEXT" ); - qglPointParameterfEXT = true; - // qglPointParameterfvEXT = ( void (APIENTRY *)( GLenum, const GLfloat * ) ) qwglGetProcAddress( "glPointParameterfvEXT" ); - VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_point_parameters\n"); - } - else { - VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_point_parameters\n"); - } - } - else { - VID.Printf(Defines.PRINT_ALL, "...GL_EXT_point_parameters not found\n"); - } - - // #ifdef __linux__ - // if ( strstr( gl_config.extensions_string, "3DFX_set_global_palette" )) - // { - // if ( gl_ext_palettedtexture->value ) - // { - // VID.Printf( Defines.PRINT_ALL, "...using 3DFX_set_global_palette\n" ); - // qgl3DfxSetPaletteEXT = ( void ( APIENTRY * ) (GLuint *) )qwglGetProcAddress( "gl3DfxSetPaletteEXT" ); - //// qglColorTableEXT = Fake_glColorTableEXT; - // } - // else - // { - // VID.Printf( Defines.PRINT_ALL, "...ignoring 3DFX_set_global_palette\n" ); - // } - // } - // else - // { - // VID.Printf( Defines.PRINT_ALL, "...3DFX_set_global_palette not found\n" ); - // } - // #endif - - if (!qglColorTableEXT - && gl_config.extensions_string.indexOf("GL_EXT_paletted_texture") >= 0 - && gl_config.extensions_string.indexOf("GL_EXT_shared_texture_palette") >= 0) { - if (gl_ext_palettedtexture.value != 0.0f) { - VID.Printf(Defines.PRINT_ALL, "...using GL_EXT_shared_texture_palette\n"); - qglColorTableEXT = false; // true; TODO jogl bug - } - else { - VID.Printf(Defines.PRINT_ALL, "...ignoring GL_EXT_shared_texture_palette\n"); - qglColorTableEXT = false; - } - } - else { - VID.Printf(Defines.PRINT_ALL, "...GL_EXT_shared_texture_palette not found\n"); - } - - if (gl_config.extensions_string.indexOf("GL_ARB_multitexture") >= 0) { - VID.Printf(Defines.PRINT_ALL, "...using GL_ARB_multitexture\n"); - qglActiveTextureARB = true; - GL_TEXTURE0 = ARBMultitexture.GL_TEXTURE0_ARB; - GL_TEXTURE1 = ARBMultitexture.GL_TEXTURE1_ARB; - } else { - VID.Printf(Defines.PRINT_ALL, "...GL_ARB_multitexture not found\n"); - } - - if (!(qglActiveTextureARB)) - return false; - - GL_SetDefaultState(); - - GL_InitImages(); - Mod_Init(); - R_InitParticleTexture(); - Draw_InitLocal(); - - int err = gl.glGetError(); - if (err != GL11.GL_NO_ERROR) - VID.Printf( - Defines.PRINT_ALL, - "glGetError() = 0x%x\n\t%s\n", - new Vargs(2).add(err).add("" + gl.glGetString(err))); - - return true; - } - - - - /** - * R_BeginFrame - */ - protected void R_BeginFrame(float camera_separation) { - - gl_state.camera_separation = camera_separation; - - /* - ** change modes if necessary - */ - if (gl_mode.modified || vid_fullscreen.modified) { - // FIXME: only restart if CDS is required - cvar_t ref; - - ref = Cvar.Get("vid_ref", "lwjgl", 0); - ref.modified = true; - } - - if (gl_log.modified) { - GLimp_EnableLogging((gl_log.value != 0.0f)); - gl_log.modified = false; - } - - if (gl_log.value != 0.0f) { - GLimp_LogNewFrame(); - } - - /* - ** update 3Dfx gamma -- it is expected that a user will do a vid_restart - ** after tweaking this value - */ - if (vid_gamma.modified) { - vid_gamma.modified = false; - - if ((gl_config.renderer & Base.GL_RENDERER_VOODOO) != 0) { - // wird erstmal nicht gebraucht - - /* - char envbuffer[1024]; - float g; - - g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F; - Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g ); - putenv( envbuffer ); - Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g ); - putenv( envbuffer ); - */ - VID.Printf(Defines.PRINT_DEVELOPER, "gamma anpassung fuer VOODOO nicht gesetzt"); - } - } - - GLimp_BeginFrame(camera_separation); - - /* - ** go into 2D mode - */ - gl.glViewport(0, 0, vid.width, vid.height); - gl.glMatrixMode(GL11.GL_PROJECTION); - gl.glLoadIdentity(); - gl.glOrtho(0, vid.width, vid.height, 0, -99999, 99999); - gl.glMatrixMode(GL11.GL_MODELVIEW); - gl.glLoadIdentity(); - gl.glDisable(GL11.GL_DEPTH_TEST); - gl.glDisable(GL11.GL_CULL_FACE); - gl.glDisable(GL11.GL_BLEND); - gl.glEnable(GL11.GL_ALPHA_TEST); - gl.glColor4f(1, 1, 1, 1); - - /* - ** draw buffer stuff - */ - if (gl_drawbuffer.modified) { - gl_drawbuffer.modified = false; - - if (gl_state.camera_separation == 0 || !gl_state.stereo_enabled) { - if (gl_drawbuffer.string.equalsIgnoreCase("GL_FRONT")) - gl.glDrawBuffer(GL11.GL_FRONT); - else - gl.glDrawBuffer(GL11.GL_BACK); - } - } - - /* - ** texturemode stuff - */ - if (gl_texturemode.modified) { - GL_TextureMode(gl_texturemode.string); - gl_texturemode.modified = false; - } - - if (gl_texturealphamode.modified) { - GL_TextureAlphaMode(gl_texturealphamode.string); - gl_texturealphamode.modified = false; - } - - if (gl_texturesolidmode.modified) { - GL_TextureSolidMode(gl_texturesolidmode.string); - gl_texturesolidmode.modified = false; - } - - /* - ** swapinterval stuff - */ - GL_UpdateSwapInterval(); - - // - // clear screen if desired - // - R_Clear(); - } - -}
\ No newline at end of file diff --git a/src/jake2/render/lwjgl/Misc.java b/src/jake2/render/lwjgl/Misc.java deleted file mode 100644 index f51cd28..0000000 --- a/src/jake2/render/lwjgl/Misc.java +++ /dev/null @@ -1,224 +0,0 @@ -/* - * Misc.java - * Copyright (C) 2003 - * - * $Id: Misc.java,v 1.9 2006-10-31 13:06:32 salomo 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.lwjgl; - -import jake2.Defines; -import jake2.client.VID; -import jake2.qcommon.FS; - -import java.io.*; -import java.nio.FloatBuffer; -import java.nio.MappedByteBuffer; -import java.nio.channels.FileChannel; - -import net.java.games.jogl.GL; - -import org.lwjgl.BufferUtils; -import org.lwjgl.opengl.*; - -/** - * Misc - * - * @author cwei - */ -public abstract class Misc extends Image { - - // /* - // ============================================================================== - // - // SCREEN SHOTS - // - // ============================================================================== - // */ - // - // typedef struct _TargaHeader { - // unsigned char id_length, colormap_type, image_type; - // unsigned short colormap_index, colormap_length; - // unsigned char colormap_size; - // unsigned short x_origin, y_origin, width, height; - // unsigned char pixel_size, attributes; - // } TargaHeader; - - private final static int TGA_HEADER_SIZE = 18; - - /* - * ================== GL_ScreenShot_f ================== - */ - protected void GL_ScreenShot_f() { - StringBuffer sb = new StringBuffer(FS.Gamedir() + "/scrshot/jake00.tga"); - FS.CreatePath(sb.toString()); - File file = new File(sb.toString()); - // find a valid file name - int i = 0; - int offset = sb.length() - 6; - while (file.exists() && i++ < 100) { - sb.setCharAt(offset, (char) ((i / 10) + '0')); - sb.setCharAt(offset + 1, (char) ((i % 10) + '0')); - file = new File(sb.toString()); - } - if (i == 100) { - VID.Printf(Defines.PRINT_ALL, "Clean up your screenshots\n"); - return; - } - - try { - RandomAccessFile out = new RandomAccessFile(file, "rw"); - FileChannel ch = out.getChannel(); - int fileLength = TGA_HEADER_SIZE + vid.width * vid.height * 3; - out.setLength(fileLength); - MappedByteBuffer image = ch.map(FileChannel.MapMode.READ_WRITE, 0, - fileLength); - - // write the TGA header - image.put(0, (byte) 0).put(1, (byte) 0); - image.put(2, (byte) 2); // uncompressed type - image.put(12, (byte) (vid.width & 0xFF)); // vid.width - image.put(13, (byte) (vid.width >> 8)); // vid.width - image.put(14, (byte) (vid.height & 0xFF)); // vid.height - image.put(15, (byte) (vid.height >> 8)); // vid.height - image.put(16, (byte) 24); // pixel size - - // go to image data position - image.position(TGA_HEADER_SIZE); - - // change pixel alignment for reading - if (vid.width % 4 != 0) { - gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1); - } - - // OpenGL 1.2+ supports the GL_BGR color format - // check the GL_VERSION to use the TARGA BGR order if possible - // e.g.: 1.5.2 NVIDIA 66.29 - if (gl_config.getOpenGLVersion() >= 1.2f) { - // read the BGR values into the image buffer - gl.glReadPixels(0, 0, vid.width, vid.height, GL12.GL_BGR, - GL.GL_UNSIGNED_BYTE, image); - } else { - // read the RGB values into the image buffer - gl.glReadPixels(0, 0, vid.width, vid.height, GL11.GL_RGB, - GL.GL_UNSIGNED_BYTE, image); - // flip RGB to BGR - byte tmp; - for (i = TGA_HEADER_SIZE; i < fileLength; i += 3) { - tmp = image.get(i); - image.put(i, image.get(i + 2)); - image.put(i + 2, tmp); - } - } - // reset to default alignment - gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 4); - // close the file channel - ch.close(); - } catch (IOException e) { - VID.Printf(Defines.PRINT_ALL, e.getMessage() + '\n'); - } - - VID.Printf(Defines.PRINT_ALL, "Wrote " + file + '\n'); - } - - /* - * * GL_SetDefaultState - */ - protected void GL_SetDefaultState() { - gl.glClearColor(1f, 0f, 0.5f, 0.5f); // original quake2 - // gl.glClearColor(0, 0, 0, 0); // replaced with black - gl.glCullFace(GL11.GL_FRONT); - gl.glEnable(GL11.GL_TEXTURE_2D); - - gl.glEnable(GL11.GL_ALPHA_TEST); - gl.glAlphaFunc(GL11.GL_GREATER, 0.666f); - - gl.glDisable(GL11.GL_DEPTH_TEST); - gl.glDisable(GL11.GL_CULL_FACE); - gl.glDisable(GL11.GL_BLEND); - - gl.glColor4f(1, 1, 1, 1); - - gl.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL); - gl.glShadeModel(GL11.GL_FLAT); - - GL_TextureMode(gl_texturemode.string); - GL_TextureAlphaMode(gl_texturealphamode.string); - GL_TextureSolidMode(gl_texturesolidmode.string); - - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, - gl_filter_min); - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, - gl_filter_max); - - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, - GL11.GL_REPEAT); - gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, - GL11.GL_REPEAT); - - gl.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); - - GL_TexEnv(GL11.GL_REPLACE); - - if (qglPointParameterfEXT) { - // float[] attenuations = { gl_particle_att_a.value, - // gl_particle_att_b.value, gl_particle_att_c.value }; - FloatBuffer att_buffer = BufferUtils.createFloatBuffer(4); - att_buffer.put(0, gl_particle_att_a.value); - att_buffer.put(1, gl_particle_att_b.value); - att_buffer.put(2, gl_particle_att_c.value); - - gl.glEnable(GL11.GL_POINT_SMOOTH); - gl.glPointParameterfEXT(EXTPointParameters.GL_POINT_SIZE_MIN_EXT, - gl_particle_min_size.value); - gl.glPointParameterfEXT(EXTPointParameters.GL_POINT_SIZE_MAX_EXT, - gl_particle_max_size.value); - gl.glPointParameterEXT( - EXTPointParameters.GL_DISTANCE_ATTENUATION_EXT, att_buffer); - } - - if (qglColorTableEXT && gl_ext_palettedtexture.value != 0.0f) { - gl.glEnable(EXTSharedTexturePalette.GL_SHARED_TEXTURE_PALETTE_EXT); - - GL_SetTexturePalette(d_8to24table); - } - - GL_UpdateSwapInterval(); - - /* - * vertex array extension - */ - gl.glEnableClientState(GL11.GL_VERTEX_ARRAY); - gl.glClientActiveTextureARB(GL_TEXTURE0); - gl.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY); - } - - protected void GL_UpdateSwapInterval() { - if (gl_swapinterval.modified) { - gl_swapinterval.modified = false; - if (!gl_state.stereo_enabled) { - if (qwglSwapIntervalEXT) { - // ((WGL)gl).wglSwapIntervalEXT((int)gl_swapinterval.value); - } - } - } - } -} diff --git a/src/jake2/render/opengl/CountGL.java b/src/jake2/render/opengl/CountGL.java new file mode 100644 index 0000000..393387b --- /dev/null +++ b/src/jake2/render/opengl/CountGL.java @@ -0,0 +1,310 @@ +package jake2.render.opengl; + + +import java.nio.*; + +public class CountGL implements QGL { + + private static int count = 0; + + private static QGL self = new CountGL(); + + private CountGL() { + // singleton + } + + public static QGL getInstance() { + return self; + } + + public void glAlphaFunc(int func, float ref) { + count++; + } + + public void glBegin(int mode) { + count++; + } + + public void glBindTexture(int target, int texture) { + count++; + } + + public void glBlendFunc(int sfactor, int dfactor) { + count++; + } + + public void glClear(int mask) { + count++; + } + + public void glClearColor(float red, float green, float blue, float alpha) { + count++; + } + + public void glColor3f(float red, float green, float blue) { + count++; + } + + public void glColor3ub(byte red, byte green, byte blue) { + count++; + } + + public void glColor4f(float red, float green, float blue, float alpha) { + count++; + } + + public void glColor4ub(byte red, byte green, byte blue, byte alpha) { + count++; + } + + public void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer) { + count++; + } + + public void glColorPointer(int size, int stride, FloatBuffer pointer) { + count++; + } + + public void glCullFace(int mode) { + count++; + } + + public void glDeleteTextures(IntBuffer textures) { + count++; + } + + public void glDepthFunc(int func) { + count++; + } + + public void glDepthMask(boolean flag) { + count++; + } + + public void glDepthRange(double zNear, double zFar) { + count++; + } + + public void glDisable(int cap) { + count++; + } + + public void glDisableClientState(int cap) { + count++; + } + + public void glDrawArrays(int mode, int first, int count) { + count++; + } + + public void glDrawBuffer(int mode) { + count++; + } + + public void glDrawElements(int mode, IntBuffer indices) { + count++; + } + + public void glEnable(int cap) { + count++; + } + + public void glEnableClientState(int cap) { + count++; + } + + public void glEnd() { + count++; + } + + public void glFinish() { + count++; + } + + public void glFlush() { + System.err.println("GL calls/frame: " + (++count)); + count = 0; + } + + public void glFrustum(double left, double right, double bottom, + double top, double zNear, double zFar) { + count++; + } + + public int glGetError() { + return GL_NO_ERROR; + } + + public void glGetFloat(int pname, FloatBuffer params) { + count++; + } + + public String glGetString(int name) { + switch (name) { + case GL_EXTENSIONS: + return "GL_ARB_multitexture"; + default: + return ""; + } + } + + public void glInterleavedArrays(int format, int stride, + FloatBuffer pointer) { + count++; + } + + public void glLoadIdentity() { + count++; + } + + public void glLoadMatrix(FloatBuffer m) { + count++; + } + + public void glMatrixMode(int mode) { + count++; + } + + public void glOrtho(double left, double right, double bottom, + double top, double zNear, double zFar) { + count++; + } + + public void glPixelStorei(int pname, int param) { + count++; + } + + public void glPointSize(float size) { + count++; + } + + public void glPolygonMode(int face, int mode) { + count++; + } + + public void glPopMatrix() { + count++; + } + + public void glPushMatrix() { + count++; + } + + public void glReadPixels(int x, int y, int width, int height, + int format, int type, ByteBuffer pixels) { + count++; + } + + public void glRotatef(float angle, float x, float y, float z) { + count++; + } + + public void glScalef(float x, float y, float z) { + count++; + } + + public void glScissor(int x, int y, int width, int height) { + count++; + } + + public void glShadeModel(int mode) { + count++; + } + + public void glTexCoord2f(float s, float t) { + count++; + } + + public void glTexCoordPointer(int size, int stride, FloatBuffer pointer) { + count++; + } + + public void glTexEnvi(int target, int pname, int param) { + count++; + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ByteBuffer pixels) { + count++; + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + IntBuffer pixels) { + count++; + } + + public void glTexParameterf(int target, int pname, float param) { + count++; + } + + public void glTexParameteri(int target, int pname, int param) { + count++; + } + + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + IntBuffer pixels) { + count++; + } + + public void glTranslatef(float x, float y, float z) { + count++; + } + + public void glVertex2f(float x, float y) { + count++; + } + + public void glVertex3f(float x, float y, float z) { + count++; + } + + public void glVertexPointer(int size, int stride, FloatBuffer pointer) { + count++; + } + + public void glViewport(int x, int y, int width, int height) { + count++; + } + + public void glColorTable(int target, int internalFormat, int width, + int format, int type, ByteBuffer data) { + count++; + } + + public void glActiveTextureARB(int texture) { + count++; + } + + public void glClientActiveTextureARB(int texture) { + count++; + } + + public void glPointParameterEXT(int pname, FloatBuffer pfParams) { + count++; + } + + public void glPointParameterfEXT(int pname, float param) { + count++; + } + + public void glLockArraysEXT(int first, int count) { + count++; + } + + public void glArrayElement(int index) { + count++; + } + + public void glUnlockArraysEXT() { + count++; + } + + public void glMultiTexCoord2f(int target, float s, float t) { + count++; + } + +} diff --git a/src/jake2/render/opengl/DummyGL.java b/src/jake2/render/opengl/DummyGL.java new file mode 100644 index 0000000..42fca3c --- /dev/null +++ b/src/jake2/render/opengl/DummyGL.java @@ -0,0 +1,307 @@ +package jake2.render.opengl; + + +import java.nio.*; + +public class DummyGL implements QGL { + + private static QGL self = new DummyGL(); + + private DummyGL() { + // singleton + } + + public static QGL getInstance() { + return self; + } + + public void glAlphaFunc(int func, float ref) { + // do nothing + } + + public void glBegin(int mode) { + // do nothing + } + + public void glBindTexture(int target, int texture) { + // do nothing + } + + public void glBlendFunc(int sfactor, int dfactor) { + // do nothing + } + + public void glClear(int mask) { + // do nothing + } + + public void glClearColor(float red, float green, float blue, float alpha) { + // do nothing + } + + public void glColor3f(float red, float green, float blue) { + // do nothing + } + + public void glColor3ub(byte red, byte green, byte blue) { + // do nothing + } + + public void glColor4f(float red, float green, float blue, float alpha) { + // do nothing + } + + public void glColor4ub(byte red, byte green, byte blue, byte alpha) { + // do nothing + } + + public void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer) { + // do nothing + } + + public void glColorPointer(int size, int stride, FloatBuffer pointer) { + // do nothing + } + + public void glCullFace(int mode) { + // do nothing + } + + public void glDeleteTextures(IntBuffer textures) { + // do nothing + } + + public void glDepthFunc(int func) { + // do nothing + } + + public void glDepthMask(boolean flag) { + // do nothing + } + + public void glDepthRange(double zNear, double zFar) { + // do nothing + } + + public void glDisable(int cap) { + // do nothing + } + + public void glDisableClientState(int cap) { + // do nothing + } + + public void glDrawArrays(int mode, int first, int count) { + // do nothing + } + + public void glDrawBuffer(int mode) { + // do nothing + } + + public void glDrawElements(int mode, IntBuffer indices) { + // do nothing + } + + public void glEnable(int cap) { + // do nothing + } + + public void glEnableClientState(int cap) { + // do nothing + } + + public void glEnd() { + // do nothing + } + + public void glFinish() { + // do nothing + } + + public void glFlush() { + // do nothing + } + + public void glFrustum(double left, double right, double bottom, + double top, double zNear, double zFar) { + // do nothing + } + + public int glGetError() { + return GL_NO_ERROR; + } + + public void glGetFloat(int pname, FloatBuffer params) { + // do nothing + } + + public String glGetString(int name) { + switch (name) { + case GL_EXTENSIONS: + return "GL_ARB_multitexture"; + default: + return ""; + } + } + + public void glInterleavedArrays(int format, int stride, + FloatBuffer pointer) { + // do nothing + } + + public void glLoadIdentity() { + // do nothing + } + + public void glLoadMatrix(FloatBuffer m) { + // do nothing + } + + public void glMatrixMode(int mode) { + // do nothing + } + + public void glOrtho(double left, double right, double bottom, + double top, double zNear, double zFar) { + // do nothing + } + + public void glPixelStorei(int pname, int param) { + // do nothing + } + + public void glPointSize(float size) { + // do nothing + } + + public void glPolygonMode(int face, int mode) { + // do nothing + } + + public void glPopMatrix() { + // do nothing + } + + public void glPushMatrix() { + // do nothing + } + + public void glReadPixels(int x, int y, int width, int height, + int format, int type, ByteBuffer pixels) { + // do nothing + } + + public void glRotatef(float angle, float x, float y, float z) { + // do nothing + } + + public void glScalef(float x, float y, float z) { + // do nothing + } + + public void glScissor(int x, int y, int width, int height) { + // do nothing + } + + public void glShadeModel(int mode) { + // do nothing + } + + public void glTexCoord2f(float s, float t) { + // do nothing + } + + public void glTexCoordPointer(int size, int stride, FloatBuffer pointer) { + // do nothing + } + + public void glTexEnvi(int target, int pname, int param) { + // do nothing + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ByteBuffer pixels) { + // do nothing + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + IntBuffer pixels) { + // do nothing + } + + public void glTexParameterf(int target, int pname, float param) { + // do nothing + } + + public void glTexParameteri(int target, int pname, int param) { + // do nothing + } + + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + IntBuffer pixels) { + // do nothing + } + + public void glTranslatef(float x, float y, float z) { + // do nothing + } + + public void glVertex2f(float x, float y) { + // do nothing + } + + public void glVertex3f(float x, float y, float z) { + // do nothing + } + + public void glVertexPointer(int size, int stride, FloatBuffer pointer) { + // do nothing + } + + public void glViewport(int x, int y, int width, int height) { + // do nothing + } + + public void glColorTable(int target, int internalFormat, int width, + int format, int type, ByteBuffer data) { + // do nothing + } + + public void glActiveTextureARB(int texture) { + // do nothing + } + + public void glClientActiveTextureARB(int texture) { + // do nothing + } + + public void glPointParameterEXT(int pname, FloatBuffer pfParams) { + // do nothing + } + + public void glPointParameterfEXT(int pname, float param) { + // do nothing + } + + public void glLockArraysEXT(int first, int count) { + // do nothing + } + + public void glArrayElement(int index) { + // do nothing + } + + public void glUnlockArraysEXT() { + // do nothing + } + + public void glMultiTexCoord2f(int target, float s, float t) { + // do nothing + } + +} diff --git a/src/jake2/render/opengl/GLDriver.java b/src/jake2/render/opengl/GLDriver.java new file mode 100644 index 0000000..aa28947 --- /dev/null +++ b/src/jake2/render/opengl/GLDriver.java @@ -0,0 +1,30 @@ +package jake2.render.opengl; + +import jake2.qcommon.xcommand_t; +import jake2.sys.KBD; + +import java.awt.Dimension; + +public interface GLDriver { + + boolean init(int xpos, int ypos); + + int setMode(Dimension dim, int mode, boolean fullscreen); + + void shutdown(); + + void beginFrame(float camera_separation); + + void endFrame(); + + void appActivate(boolean activate); + + void enableLogging(boolean enable); + + void logNewFrame(); + + java.awt.DisplayMode[] getModeList(); + + void updateScreen(xcommand_t callback); + +} diff --git a/src/jake2/render/JoglBase.java b/src/jake2/render/opengl/JoglDriver.java index 3fb3489..53a6d47 100644 --- a/src/jake2/render/JoglBase.java +++ b/src/jake2/render/opengl/JoglDriver.java @@ -2,7 +2,7 @@ * JoglCommon.java * Copyright (C) 2004 * - * $Id: JoglBase.java,v 1.16 2006-10-31 13:06:32 salomo Exp $ + * $Id: JoglDriver.java,v 1.2 2006-11-21 00:49:54 cawe Exp $ */ /* Copyright (C) 1997-2001 Id Software, Inc. @@ -24,16 +24,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -package jake2.render; +package jake2.render.opengl; import jake2.Defines; import jake2.client.VID; -import jake2.client.viddef_t; -import jake2.game.cvar_t; import jake2.qcommon.Cbuf; import jake2.qcommon.xcommand_t; -import jake2.render.common.Model; -import jake2.render.fastjogl.GLWrapJogl; +import jake2.render.Base; import jake2.sys.JOGLKBD; import java.awt.*; @@ -45,37 +42,34 @@ import javax.swing.ImageIcon; import javax.swing.JFrame; import net.java.games.jogl.*; -import net.java.games.jogl.util.GLUT; /** * JoglCommon */ -public abstract class JoglBase extends jake2.render.common.Misc - implements GLEventListener { - - // IMPORTED FUNCTIONS - protected GraphicsDevice device; - protected DisplayMode oldDisplayMode; - protected GLCanvas canvas; +public class JoglDriver extends JoglGL implements GLDriver, GLEventListener { + + protected JoglDriver() { + // see JoglRenderer + } + + private GraphicsDevice device; + private DisplayMode oldDisplayMode; + private GLCanvas canvas; JFrame window; - protected GL gl; - protected GLU glu; - protected GLUT glut = new GLUT(); - - + // window position on the screen + int window_xpos, window_ypos; // handles the post initialization with JoglRenderer protected boolean post_init = false; protected boolean contextInUse = false; - protected abstract boolean R_Init2(); protected final xcommand_t INIT_CALLBACK = new xcommand_t() { public void execute() { // only used for the first run (initialization) // clear the screen - gl.glClearColor(0, 0, 0, 0); - gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); + glClearColor(0, 0, 0, 0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // // check the post init process @@ -84,11 +78,12 @@ public abstract class JoglBase extends jake2.render.common.Misc VID.Printf(Defines.PRINT_ALL, "Missing multi-texturing for FastJOGL renderer\n"); } - GLimp_EndFrame(); + endFrame(); } }; - protected xcommand_t callback = INIT_CALLBACK; - + + xcommand_t callback = INIT_CALLBACK; + public DisplayMode[] getModeList() { DisplayMode[] modes = device.getDisplayModes(); LinkedList l = new LinkedList(); @@ -157,9 +152,9 @@ public abstract class JoglBase extends jake2.render.common.Misc * @param dim * @param mode * @param fullscreen - * @return enum rserr_t + * @return enum Base.rserr_t */ - protected int GLimp_SetMode(Dimension dim, int mode, boolean fullscreen) { + public int setMode(Dimension dim, int mode, boolean fullscreen) { Dimension newDim = new Dimension(); @@ -179,15 +174,15 @@ public abstract class JoglBase extends jake2.render.common.Misc if (!VID.GetModeInfo(newDim, mode)) { VID.Printf(Defines.PRINT_ALL, " invalid mode\n"); - return rserr_invalid_mode; + return Base.rserr_invalid_mode; } VID.Printf(Defines.PRINT_ALL, " " + newDim.width + " " + newDim.height + '\n'); // destroy the existing window - GLimp_Shutdown(); + shutdown(); - window = new JFrame("Jake2"); + window = new JFrame("Jake2 (jogl)"); ImageIcon icon = new ImageIcon(getClass().getResource("/icon-small.png")); window.setIconImage(icon.getImage()); @@ -257,16 +252,15 @@ public abstract class JoglBase extends jake2.render.common.Misc this.canvas = canvas; - vid.width = newDim.width; - vid.height = newDim.height; + Base.setVid(newDim.width, newDim.height); // let the sound and input subsystems know about the new window - VID.NewWindow(vid.width, vid.height); + VID.NewWindow(newDim.width, newDim.height); - return rserr_ok; + return Base.rserr_ok; } - protected void GLimp_Shutdown() { + public void shutdown() { if (oldDisplayMode != null && device.getFullScreenWindow() != null) { try { if (device.isFullScreenSupported()) @@ -292,40 +286,35 @@ public abstract class JoglBase extends jake2.render.common.Misc /** * @return true */ - protected boolean GLimp_Init(int xpos, int ypos) { + public boolean init(int xpos, int ypos) { // do nothing window_xpos = xpos; window_ypos = ypos; return true; } - protected void GLimp_EndFrame() { - gl.glFlush(); + public void beginFrame(float camera_separation) { + // do nothing + } + + public void endFrame() { + glFlush(); canvas.swapBuffers(); } - protected void GLimp_BeginFrame(float camera_separation) { - // do nothing - } + + public void appActivate(boolean activate) { + // do nothing + } - protected void GLimp_AppActivate(boolean activate) { - // do nothing - } + public void enableLogging(boolean enable) { + // do nothing + } - protected void GLimp_EnableLogging(boolean enable) { - // doesn't need jogl logging - // do nothing - } + public void logNewFrame() { + // do nothing + } - protected void GLimp_LogNewFrame() { - // doesn't need jogl logging - // do nothing - } - - protected void GLimp_Finish() { - gl.glFinish(); - } - - /* + /* * @see jake2.client.refexport_t#updateScreen() */ public void updateScreen() { @@ -345,20 +334,14 @@ public abstract class JoglBase extends jake2.render.common.Misc * @see net.java.games.jogl.GLEventListener#init(net.java.games.jogl.GLDrawable) */ public void init(GLDrawable drawable) { - this.gl = drawable.getGL(); - ggl = new GLWrapJogl (this.gl); - this.glu = drawable.getGLU(); - - // this is a hack to run R_init() in gl context - post_init = R_Init2(); + setGL(drawable.getGL()); } /* * @see net.java.games.jogl.GLEventListener#display(net.java.games.jogl.GLDrawable) */ public void display(GLDrawable drawable) { - this.gl = drawable.getGL(); - this.glu = drawable.getGLU(); + setGL(drawable.getGL()); contextInUse = true; callback.execute(); @@ -378,5 +361,5 @@ public abstract class JoglBase extends jake2.render.common.Misc public void reshape(GLDrawable drawable, int x, int y, int width, int height) { // do nothing } - + } diff --git a/src/jake2/render/opengl/JoglGL.java b/src/jake2/render/opengl/JoglGL.java new file mode 100644 index 0000000..d3e37b5 --- /dev/null +++ b/src/jake2/render/opengl/JoglGL.java @@ -0,0 +1,307 @@ +package jake2.render.opengl; + + +import java.nio.*; + +import net.java.games.jogl.GL; + +public class JoglGL implements QGL { + + private GL jogl; + + JoglGL() { + // singleton + } + + void setGL(GL context) { + this.jogl = context; + } + + public void glAlphaFunc(int func, float ref) { + jogl.glAlphaFunc(func, ref); + } + + public void glBegin(int mode) { + jogl.glBegin(mode); + } + + public void glBindTexture(int target, int texture) { + jogl.glBindTexture(target, texture); + } + + public void glBlendFunc(int sfactor, int dfactor) { + jogl.glBlendFunc(sfactor, dfactor); + } + + public void glClear(int mask) { + jogl.glClear(mask); + } + + public void glClearColor(float red, float green, float blue, float alpha) { + jogl.glClearColor(red, green, blue, alpha); + } + + public void glColor3f(float red, float green, float blue) { + jogl.glColor3f(red, green, blue); + } + + public void glColor3ub(byte red, byte green, byte blue) { + jogl.glColor3ub(red, green, blue); + } + + public void glColor4f(float red, float green, float blue, float alpha) { + jogl.glColor4f(red, green, blue, alpha); + } + + public void glColor4ub(byte red, byte green, byte blue, byte alpha) { + jogl.glColor4ub(red, green, blue, alpha); + } + + public void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer) { + jogl.glColorPointer(size, GL_UNSIGNED_BYTE, stride, pointer); + } + + public void glColorPointer(int size, int stride, FloatBuffer pointer) { + jogl.glColorPointer(size, GL_FLOAT, stride, pointer); + } + + public void glCullFace(int mode) { + jogl.glCullFace(mode); + } + + public void glDeleteTextures(IntBuffer textures) { + jogl.glDeleteTextures(textures.limit(), textures); + } + + public void glDepthFunc(int func) { + jogl.glDepthFunc(func); + } + + public void glDepthMask(boolean flag) { + jogl.glDepthMask(flag); + } + + public void glDepthRange(double zNear, double zFar) { + jogl.glDepthRange(zNear, zFar); + } + + public void glDisable(int cap) { + jogl.glDisable(cap); + } + + public void glDisableClientState(int cap) { + jogl.glDisableClientState(cap); + } + + public void glDrawArrays(int mode, int first, int count) { + jogl.glDrawArrays(mode, first, count); + } + + public void glDrawBuffer(int mode) { + jogl.glDrawBuffer(mode); + } + + public void glDrawElements(int mode, IntBuffer indices) { + jogl.glDrawElements(mode, indices.limit(), GL_UNSIGNED_INT, indices); + } + + public void glEnable(int cap) { + jogl.glEnable(cap); + } + + public void glEnableClientState(int cap) { + jogl.glEnableClientState(cap); + } + + public void glEnd() { + jogl.glEnd(); + } + + public void glFinish() { + jogl.glFinish(); + } + + public void glFlush() { + jogl.glFlush(); + } + + public void glFrustum(double left, double right, double bottom, + double top, double zNear, double zFar) { + jogl.glFrustum(left, right, bottom, top, zNear, zFar); + } + + public int glGetError() { + return jogl.glGetError(); + } + + public void glGetFloat(int pname, FloatBuffer params) { + jogl.glGetFloatv(pname, params); + } + + public String glGetString(int name) { + return jogl.glGetString(name); + } + + public void glInterleavedArrays(int format, int stride, + FloatBuffer pointer) { + jogl.glInterleavedArrays(format, stride, pointer); + } + + public void glLoadIdentity() { + jogl.glLoadIdentity(); + } + + public void glLoadMatrix(FloatBuffer m) { + jogl.glLoadMatrixf(m); + } + + public void glMatrixMode(int mode) { + jogl.glMatrixMode(mode); + } + + public void glOrtho(double left, double right, double bottom, + double top, double zNear, double zFar) { + jogl.glOrtho(left, right, bottom, top, zNear, zFar); + } + + public void glPixelStorei(int pname, int param) { + jogl.glPixelStorei(pname, param); + } + + public void glPointSize(float size) { + jogl.glPointSize(size); + } + + public void glPolygonMode(int face, int mode) { + jogl.glPolygonMode(face, mode); + } + + public void glPopMatrix() { + jogl.glPopMatrix(); + } + + public void glPushMatrix() { + jogl.glPushMatrix(); + } + + public void glReadPixels(int x, int y, int width, int height, + int format, int type, ByteBuffer pixels) { + jogl.glReadPixels(x, y, width, height, format, type, pixels); + } + + public void glRotatef(float angle, float x, float y, float z) { + jogl.glRotatef(angle, x, y, z); + } + + public void glScalef(float x, float y, float z) { + jogl.glScalef(x, y, z); + } + + public void glScissor(int x, int y, int width, int height) { + jogl.glScissor(x, y, width, height); + } + + public void glShadeModel(int mode) { + jogl.glShadeModel(mode); + } + + public void glTexCoord2f(float s, float t) { + jogl.glTexCoord2f(s, t); + } + + public void glTexCoordPointer(int size, int stride, FloatBuffer pointer) { + jogl.glTexCoordPointer(size, GL_FLOAT, stride, pointer); + } + + public void glTexEnvi(int target, int pname, int param) { + jogl.glTexEnvi(target, pname, param); + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ByteBuffer pixels) { + jogl.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + IntBuffer pixels) { + jogl.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + + public void glTexParameterf(int target, int pname, float param) { + jogl.glTexParameterf(target, pname, param); + } + + public void glTexParameteri(int target, int pname, int param) { + jogl.glTexParameteri(target, pname, param); + } + + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + IntBuffer pixels) { + jogl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, + format, type, pixels); + } + + public void glTranslatef(float x, float y, float z) { + jogl.glTranslatef(x, y, z); + } + + public void glVertex2f(float x, float y) { + jogl.glVertex2f(x, y); + } + + public void glVertex3f(float x, float y, float z) { + jogl.glVertex3f(x, y, z); + } + + public void glVertexPointer(int size, int stride, FloatBuffer pointer) { + jogl.glVertexPointer(size, GL_FLOAT, stride, pointer); + } + + public void glViewport(int x, int y, int width, int height) { + jogl.glViewport(x, y, width, height); + } + + public void glColorTable(int target, int internalFormat, int width, + int format, int type, ByteBuffer data) { + jogl.glColorTable(target, internalFormat, width, format, type, data); + } + + public void glActiveTextureARB(int texture) { + jogl.glActiveTextureARB(texture); + } + + public void glClientActiveTextureARB(int texture) { + jogl.glClientActiveTextureARB(texture); + } + + public void glPointParameterEXT(int pname, FloatBuffer pfParams) { + jogl.glPointParameterfvEXT(pname, pfParams); + } + + public void glPointParameterfEXT(int pname, float param) { + jogl.glPointParameterfEXT(pname, param); + } + public void glLockArraysEXT(int first, int count) { + jogl.glLockArraysEXT(first, count); + } + + public void glArrayElement(int index) { + jogl.glArrayElement(index); + } + + public void glUnlockArraysEXT() { + jogl.glUnlockArraysEXT(); + } + + public void glMultiTexCoord2f(int target, float s, float t) { + jogl.glMultiTexCoord2f(target, s, t); + } + + +} diff --git a/src/jake2/render/opengl/Jsr231Driver.java b/src/jake2/render/opengl/Jsr231Driver.java new file mode 100644 index 0000000..f4feddb --- /dev/null +++ b/src/jake2/render/opengl/Jsr231Driver.java @@ -0,0 +1,338 @@ +/* + * JoglCommon.java + * Copyright (C) 2004 + * + * $Id: Jsr231Driver.java,v 1.2 2006-11-21 00:49:54 cawe 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.opengl; + +import jake2.Defines; +import jake2.client.VID; +import jake2.qcommon.Cbuf; +import jake2.qcommon.xcommand_t; +import jake2.render.Base; +import jake2.sys.JOGLKBD; + +import java.awt.*; +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.util.LinkedList; + +import javax.media.opengl.*; +import javax.swing.ImageIcon; +import javax.swing.JFrame; + +/** + * JoglCommon + */ +public class Jsr231Driver extends Jsr231GL implements GLDriver { + + protected Jsr231Driver() { + // singleton + } + + private GraphicsDevice device; + private DisplayMode oldDisplayMode; + private Display display; + JFrame window; + + // window position on the screen + int window_xpos, window_ypos; + + public DisplayMode[] getModeList() { + DisplayMode[] modes = device.getDisplayModes(); + LinkedList l = new LinkedList(); + l.add(oldDisplayMode); + + for (int i = 0; i < modes.length; i++) { + DisplayMode m = modes[i]; + + if (m.getBitDepth() != oldDisplayMode.getBitDepth()) continue; + if (m.getRefreshRate() > oldDisplayMode.getRefreshRate()) continue; + if (m.getHeight() < 240 || m.getWidth() < 320) continue; + + int j = 0; + DisplayMode ml = null; + for (j = 0; j < l.size(); j++) { + ml = (DisplayMode)l.get(j); + if (ml.getWidth() > m.getWidth()) break; + if (ml.getWidth() == m.getWidth() && ml.getHeight() >= m.getHeight()) break; + } + if (j == l.size()) { + l.addLast(m); + } else if (ml.getWidth() > m.getWidth() || ml.getHeight() > m.getHeight()) { + l.add(j, m); + } else if (m.getRefreshRate() > ml.getRefreshRate()){ + l.remove(j); + l.add(j, m); + } + } + DisplayMode[] ma = new DisplayMode[l.size()]; + l.toArray(ma); + return ma; + } + + DisplayMode findDisplayMode(Dimension dim) { + DisplayMode mode = null; + DisplayMode m = null; + DisplayMode[] modes = getModeList(); + int w = dim.width; + int h = dim.height; + + for (int i = 0; i < modes.length; i++) { + m = modes[i]; + if (m.getWidth() == w && m.getHeight() == h) { + mode = m; + break; + } + } + if (mode == null) mode = oldDisplayMode; + return mode; + } + + String getModeString(DisplayMode m) { + StringBuffer sb = new StringBuffer(); + sb.append(m.getWidth()); + sb.append('x'); + sb.append(m.getHeight()); + sb.append('x'); + sb.append(m.getBitDepth()); + sb.append('@'); + sb.append(m.getRefreshRate()); + sb.append("Hz"); + return sb.toString(); + } + + /** + * @param dim + * @param mode + * @param fullscreen + * @return enum Base.rserr_t + */ + public int setMode(Dimension dim, int mode, boolean fullscreen) { + + Dimension newDim = new Dimension(); + + VID.Printf(Defines.PRINT_ALL, "Initializing OpenGL display\n"); + + VID.Printf(Defines.PRINT_ALL, "...setting mode " + mode + ":"); + + /* + * fullscreen handling + */ + GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment(); + device = env.getDefaultScreenDevice(); + + if (oldDisplayMode == null) { + oldDisplayMode = device.getDisplayMode(); + } + + if (!VID.GetModeInfo(newDim, mode)) { + VID.Printf(Defines.PRINT_ALL, " invalid mode\n"); + return Base.rserr_invalid_mode; + } + + VID.Printf(Defines.PRINT_ALL, " " + newDim.width + " " + newDim.height + '\n'); + + // destroy the existing window + shutdown(); + + window = new JFrame("Jake2 (jsr231)"); + ImageIcon icon = new ImageIcon(getClass().getResource("/icon-small.png")); + window.setIconImage(icon.getImage()); + + Display canvas = new Display(); + // we want keypressed events for TAB key + canvas.setFocusTraversalKeysEnabled(false); + + window.getContentPane().add(canvas); + canvas.setSize(newDim.width, newDim.height); + + // register event listener + window.addWindowListener(new WindowAdapter() { + public void windowClosing(WindowEvent e) { + Cbuf.ExecuteText(Defines.EXEC_APPEND, "quit"); + } + }); + + // D I F F E R E N T J A K E 2 E V E N T P R O C E S S I N G + window.addComponentListener(JOGLKBD.listener); + canvas.addKeyListener(JOGLKBD.listener); + canvas.addMouseListener(JOGLKBD.listener); + canvas.addMouseMotionListener(JOGLKBD.listener); + canvas.addMouseWheelListener(JOGLKBD.listener); + + if (fullscreen) { + + DisplayMode displayMode = findDisplayMode(newDim); + + newDim.width = displayMode.getWidth(); + newDim.height = displayMode.getHeight(); + window.setUndecorated(true); + window.setResizable(false); + + device.setFullScreenWindow(window); + + if (device.isFullScreenSupported()) + device.setDisplayMode(displayMode); + + window.setLocation(0, 0); + window.setSize(displayMode.getWidth(), displayMode.getHeight()); + canvas.setSize(displayMode.getWidth(), displayMode.getHeight()); + + VID.Printf(Defines.PRINT_ALL, "...setting fullscreen " + getModeString(displayMode) + '\n'); + + } else { + window.setLocation(window_xpos, window_ypos); + window.pack(); + window.setResizable(false); + window.setVisible(true); + } + + while (!canvas.isDisplayable()) { + try { + Thread.sleep(50); + } catch (InterruptedException e) {} + } + canvas.requestFocus(); + + this.display = canvas; + + Base.setVid(newDim.width, newDim.height); + + // let the sound and input subsystems know about the new window + VID.NewWindow(newDim.width, newDim.height); + setGL(display.getGL()); + + return Base.rserr_ok; + } + + public void shutdown() { + if (oldDisplayMode != null && device.getFullScreenWindow() != null) { + try { + if (device.isFullScreenSupported()) + device.setDisplayMode(oldDisplayMode); + device.setFullScreenWindow(null); + } catch (Exception e) { + e.printStackTrace(); + } + } + if (window != null) { + display.destroy(); + window.dispose(); + } + } + + /** + * @return true + */ + public boolean init(int xpos, int ypos) { + // set window position + window_xpos = xpos; + window_ypos = ypos; + return true; + } + + public void beginFrame(float camera_separation) { + display.activate(); + } + + public void endFrame() { + glFlush(); + display.update(); + } + + public void appActivate(boolean activate) { + // do nothing + } + + public void enableLogging(boolean enable) { + // do nothing + } + + public void logNewFrame() { + // do nothing + } + + /* + * @see jake2.client.refexport_t#updateScreen() + */ + + public void updateScreen(xcommand_t callback) { + callback.execute(); + } + + protected void activate() { + display.activate(); + } + + // -------------------------------------------------------------------------- + + private class Display extends Canvas { + private GLDrawable drawable; + + private GLContext context; + + public Display() { + drawable = GLDrawableFactory.getFactory().getGLDrawable(this, + new GLCapabilities(), null); + context = drawable.createContext(null); + } + + GL getGL() { + activate(); + return context.getGL(); + } + + public void addNotify() { + super.addNotify(); + drawable.setRealized(true); + } + + public void removeNotify() { + drawable.setRealized(false); + super.removeNotify(); + } + + void activate() { + if (GLContext.getCurrent() != context) + context.makeCurrent(); + } + + private void release() { + if (GLContext.getCurrent() == context) + context.release(); + } + + void update() { + release(); + drawable.swapBuffers(); + } + + void destroy() { + release(); + context.destroy(); + drawable.setRealized(false); + } + } +} diff --git a/src/jake2/render/opengl/Jsr231GL.java b/src/jake2/render/opengl/Jsr231GL.java new file mode 100644 index 0000000..a4fef10 --- /dev/null +++ b/src/jake2/render/opengl/Jsr231GL.java @@ -0,0 +1,307 @@ +package jake2.render.opengl; + + +import java.nio.*; + +import javax.media.opengl.GL; + +public class Jsr231GL implements QGL { + + private GL gl; + + Jsr231GL() { + // singleton + } + + void setGL(GL gl) { + this.gl = gl; + } + + public void glAlphaFunc(int func, float ref) { + gl.glAlphaFunc(func, ref); + } + + public void glBegin(int mode) { + gl.glBegin(mode); + } + + public void glBindTexture(int target, int texture) { + gl.glBindTexture(target, texture); + } + + public void glBlendFunc(int sfactor, int dfactor) { + gl.glBlendFunc(sfactor, dfactor); + } + + public void glClear(int mask) { + gl.glClear(mask); + } + + public void glClearColor(float red, float green, float blue, float alpha) { + gl.glClearColor(red, green, blue, alpha); + } + + public void glColor3f(float red, float green, float blue) { + gl.glColor3f(red, green, blue); + } + + public void glColor3ub(byte red, byte green, byte blue) { + gl.glColor3ub(red, green, blue); + } + + public void glColor4f(float red, float green, float blue, float alpha) { + gl.glColor4f(red, green, blue, alpha); + } + + public void glColor4ub(byte red, byte green, byte blue, byte alpha) { + gl.glColor4ub(red, green, blue, alpha); + } + + public void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer) { + gl.glColorPointer(size, GL_UNSIGNED_BYTE, stride, pointer); + } + + public void glColorPointer(int size, int stride, FloatBuffer pointer) { + gl.glColorPointer(size, GL_FLOAT, stride, pointer); + } + + public void glCullFace(int mode) { + gl.glCullFace(mode); + } + + public void glDeleteTextures(IntBuffer textures) { + gl.glDeleteTextures(textures.limit(), textures); + } + + public void glDepthFunc(int func) { + gl.glDepthFunc(func); + } + + public void glDepthMask(boolean flag) { + gl.glDepthMask(flag); + } + + public void glDepthRange(double zNear, double zFar) { + gl.glDepthRange(zNear, zFar); + } + + public void glDisable(int cap) { + gl.glDisable(cap); + } + + public void glDisableClientState(int cap) { + gl.glDisableClientState(cap); + } + + public void glDrawArrays(int mode, int first, int count) { + gl.glDrawArrays(mode, first, count); + } + + public void glDrawBuffer(int mode) { + gl.glDrawBuffer(mode); + } + + public void glDrawElements(int mode, IntBuffer indices) { + gl.glDrawElements(mode, indices.limit(), GL_UNSIGNED_INT, indices); + } + + public void glEnable(int cap) { + gl.glEnable(cap); + } + + public void glEnableClientState(int cap) { + gl.glEnableClientState(cap); + } + + public void glEnd() { + gl.glEnd(); + } + + public void glFinish() { + gl.glFinish(); + } + + public void glFlush() { + gl.glFlush(); + } + + public void glFrustum(double left, double right, double bottom, + double top, double zNear, double zFar) { + gl.glFrustum(left, right, bottom, top, zNear, zFar); + } + + public int glGetError() { + return gl.glGetError(); + } + + public void glGetFloat(int pname, FloatBuffer params) { + gl.glGetFloatv(pname, params); + } + + public String glGetString(int name) { + return gl.glGetString(name); + } + + public void glInterleavedArrays(int format, int stride, + FloatBuffer pointer) { + gl.glInterleavedArrays(format, stride, pointer); + } + + public void glLoadIdentity() { + gl.glLoadIdentity(); + } + + public void glLoadMatrix(FloatBuffer m) { + gl.glLoadMatrixf(m); + } + + public void glMatrixMode(int mode) { + gl.glMatrixMode(mode); + } + + public void glOrtho(double left, double right, double bottom, + double top, double zNear, double zFar) { + gl.glOrtho(left, right, bottom, top, zNear, zFar); + } + + public void glPixelStorei(int pname, int param) { + gl.glPixelStorei(pname, param); + } + + public void glPointSize(float size) { + gl.glPointSize(size); + } + + public void glPolygonMode(int face, int mode) { + gl.glPolygonMode(face, mode); + } + + public void glPopMatrix() { + gl.glPopMatrix(); + } + + public void glPushMatrix() { + gl.glPushMatrix(); + } + + public void glReadPixels(int x, int y, int width, int height, + int format, int type, ByteBuffer pixels) { + gl.glReadPixels(x, y, width, height, format, type, pixels); + } + + public void glRotatef(float angle, float x, float y, float z) { + gl.glRotatef(angle, x, y, z); + } + + public void glScalef(float x, float y, float z) { + gl.glScalef(x, y, z); + } + + public void glScissor(int x, int y, int width, int height) { + gl.glScissor(x, y, width, height); + } + + public void glShadeModel(int mode) { + gl.glShadeModel(mode); + } + + public void glTexCoord2f(float s, float t) { + gl.glTexCoord2f(s, t); + } + + public void glTexCoordPointer(int size, int stride, FloatBuffer pointer) { + gl.glTexCoordPointer(size, GL_FLOAT, stride, pointer); + } + + public void glTexEnvi(int target, int pname, int param) { + gl.glTexEnvi(target, pname, param); + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ByteBuffer pixels) { + gl.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + + public void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + IntBuffer pixels) { + gl.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + + public void glTexParameterf(int target, int pname, float param) { + gl.glTexParameterf(target, pname, param); + } + + public void glTexParameteri(int target, int pname, int param) { + gl.glTexParameteri(target, pname, param); + } + + public void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + IntBuffer pixels) { + gl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, + format, type, pixels); + } + + public void glTranslatef(float x, float y, float z) { + gl.glTranslatef(x, y, z); + } + + public void glVertex2f(float x, float y) { + gl.glVertex2f(x, y); + } + + public void glVertex3f(float x, float y, float z) { + gl.glVertex3f(x, y, z); + } + + public void glVertexPointer(int size, int stride, FloatBuffer pointer) { + gl.glVertexPointer(size, GL_FLOAT, stride, pointer); + } + + public void glViewport(int x, int y, int width, int height) { + gl.glViewport(x, y, width, height); + } + + public void glColorTable(int target, int internalFormat, int width, + int format, int type, ByteBuffer data) { + gl.glColorTable(target, internalFormat, width, format, type, data); + } + + public void glActiveTextureARB(int texture) { + gl.glActiveTexture(texture); + } + + public void glClientActiveTextureARB(int texture) { + gl.glClientActiveTexture(texture); + } + + public void glPointParameterEXT(int pname, FloatBuffer pfParams) { + gl.glPointParameterfvEXT(pname, pfParams); + } + + public void glPointParameterfEXT(int pname, float param) { + gl.glPointParameterfEXT(pname, param); + } + public void glLockArraysEXT(int first, int count) { + gl.glLockArraysEXT(first, count); + } + + public void glArrayElement(int index) { + gl.glArrayElement(index); + } + + public void glUnlockArraysEXT() { + gl.glUnlockArraysEXT(); + } + + public void glMultiTexCoord2f(int target, float s, float t) { + gl.glMultiTexCoord2f(target, s, t); + } + + +} diff --git a/src/jake2/render/opengl/LwjglDriver.java b/src/jake2/render/opengl/LwjglDriver.java new file mode 100644 index 0000000..04f30bf --- /dev/null +++ b/src/jake2/render/opengl/LwjglDriver.java @@ -0,0 +1,330 @@ +/* + * LWJGLBase.java + * Copyright (C) 2004 + * + * $Id: LwjglDriver.java,v 1.2 2006-11-21 00:49:54 cawe 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.opengl; + +import jake2.Defines; +import jake2.client.VID; +import jake2.qcommon.Com; +import jake2.qcommon.xcommand_t; +import jake2.render.Base; + +import java.awt.Dimension; +import java.util.LinkedList; + +import org.lwjgl.LWJGLException; +import org.lwjgl.opengl.Display; +import org.lwjgl.opengl.DisplayMode; + +/** + * LWJGLBase + * + * @author dsanders/cwei + */ +public class LwjglDriver extends LwjglGL implements GLDriver { + + protected LwjglDriver() { + // see LwjglRenderer + } + + private DisplayMode oldDisplayMode; + + // window position on the screen + int window_xpos, window_ypos; + + private java.awt.DisplayMode toAwtDisplayMode(DisplayMode m) { + return new java.awt.DisplayMode(m.getWidth(), m.getHeight(), m + .getBitsPerPixel(), m.getFrequency()); + } + + public java.awt.DisplayMode[] getModeList() { + DisplayMode[] modes; + try { + modes = Display.getAvailableDisplayModes(); + } catch (LWJGLException e) { + Com.Println(e.getMessage()); + return new java.awt.DisplayMode[0]; + } + LinkedList l = new LinkedList(); + l.add(toAwtDisplayMode(oldDisplayMode)); + + for (int i = 0; i < modes.length; i++) { + DisplayMode m = modes[i]; + + if (m.getBitsPerPixel() != oldDisplayMode.getBitsPerPixel()) + continue; + if (m.getFrequency() > oldDisplayMode.getFrequency()) + continue; + if (m.getHeight() < 240 || m.getWidth() < 320) + continue; + + int j = 0; + java.awt.DisplayMode ml = null; + for (j = 0; j < l.size(); j++) { + ml = (java.awt.DisplayMode) l.get(j); + if (ml.getWidth() > m.getWidth()) + break; + if (ml.getWidth() == m.getWidth() + && ml.getHeight() >= m.getHeight()) + break; + } + if (j == l.size()) { + l.addLast(toAwtDisplayMode(m)); + } else if (ml.getWidth() > m.getWidth() + || ml.getHeight() > m.getHeight()) { + l.add(j, toAwtDisplayMode(m)); + } else if (m.getFrequency() > ml.getRefreshRate()) { + l.remove(j); + l.add(j, toAwtDisplayMode(m)); + } + } + java.awt.DisplayMode[] ma = new java.awt.DisplayMode[l.size()]; + l.toArray(ma); + return ma; + } + + public DisplayMode[] getLWJGLModeList() { + DisplayMode[] modes; + try { + modes = Display.getAvailableDisplayModes(); + } catch (LWJGLException e) { + Com.Println(e.getMessage()); + return new DisplayMode[0]; + } + + LinkedList l = new LinkedList(); + l.add(oldDisplayMode); + + for (int i = 0; i < modes.length; i++) { + DisplayMode m = modes[i]; + + if (m.getBitsPerPixel() != oldDisplayMode.getBitsPerPixel()) + continue; + if (m.getFrequency() > oldDisplayMode.getFrequency()) + continue; + if (m.getHeight() < 240 || m.getWidth() < 320) + continue; + + int j = 0; + DisplayMode ml = null; + for (j = 0; j < l.size(); j++) { + ml = (DisplayMode) l.get(j); + if (ml.getWidth() > m.getWidth()) + break; + if (ml.getWidth() == m.getWidth() + && ml.getHeight() >= m.getHeight()) + break; + } + if (j == l.size()) { + l.addLast(m); + } else if (ml.getWidth() > m.getWidth() + || ml.getHeight() > m.getHeight()) { + l.add(j, m); + } else if (m.getFrequency() > ml.getFrequency()) { + l.remove(j); + l.add(j, m); + } + } + DisplayMode[] ma = new DisplayMode[l.size()]; + l.toArray(ma); + return ma; + } + + private DisplayMode findDisplayMode(Dimension dim) { + DisplayMode mode = null; + DisplayMode m = null; + DisplayMode[] modes = getLWJGLModeList(); + int w = dim.width; + int h = dim.height; + + for (int i = 0; i < modes.length; i++) { + m = modes[i]; + if (m.getWidth() == w && m.getHeight() == h) { + mode = m; + break; + } + } + if (mode == null) + mode = oldDisplayMode; + return mode; + } + + String getModeString(DisplayMode m) { + StringBuffer sb = new StringBuffer(); + sb.append(m.getWidth()); + sb.append('x'); + sb.append(m.getHeight()); + sb.append('x'); + sb.append(m.getBitsPerPixel()); + sb.append('@'); + sb.append(m.getFrequency()); + sb.append("Hz"); + return sb.toString(); + } + + /** + * @param dim + * @param mode + * @param fullscreen + * @return enum rserr_t + */ + public int setMode(Dimension dim, int mode, boolean fullscreen) { + + Dimension newDim = new Dimension(); + + VID.Printf(Defines.PRINT_ALL, "Initializing OpenGL display\n"); + + VID.Printf(Defines.PRINT_ALL, "...setting mode " + mode + ":"); + + /* + * fullscreen handling + */ + if (oldDisplayMode == null) { + oldDisplayMode = Display.getDisplayMode(); + } + + if (!VID.GetModeInfo(newDim, mode)) { + VID.Printf(Defines.PRINT_ALL, " invalid mode\n"); + return Base.rserr_invalid_mode; + } + + VID.Printf(Defines.PRINT_ALL, " " + newDim.width + " " + newDim.height + + '\n'); + + // destroy the existing window + shutdown(); + + Display.setTitle("Jake2 (lwjgl)"); + Display.setLocation(0, 0); + + DisplayMode displayMode = findDisplayMode(newDim); + newDim.width = displayMode.getWidth(); + newDim.height = displayMode.getHeight(); + + if (fullscreen) { + try { + Display.setDisplayMode(displayMode); + } catch (LWJGLException e) { + return Base.rserr_invalid_mode; + } + + Display.setLocation(0, 0); + + try { + Display.setFullscreen(fullscreen); + } catch (LWJGLException e) { + return Base.rserr_invalid_fullscreen; + } + + VID.Printf(Defines.PRINT_ALL, "...setting fullscreen " + + getModeString(displayMode) + '\n'); + + } else { + try { + Display.setDisplayMode(displayMode); + } catch (LWJGLException e) { + return Base.rserr_invalid_mode; + } + + try { + Display.setFullscreen(false); + } catch (LWJGLException e) { + return Base.rserr_invalid_fullscreen; + } + Display.setLocation(window_xpos, window_ypos); + } + + Base.setVid(newDim.width, newDim.height); + + // vid.width = newDim.width; + // vid.height = newDim.height; + + try { + Display.create(); + } catch (LWJGLException e) { + return Base.rserr_unknown; + } + + // let the sound and input subsystems know about the new window + VID.NewWindow(newDim.width, newDim.height); + return Base.rserr_ok; + } + + public void shutdown() { + if (oldDisplayMode != null && Display.isFullscreen()) { + try { + Display.setDisplayMode(oldDisplayMode); + } catch (Exception e) { + e.printStackTrace(); + } + } + + while (Display.isCreated()) { + Display.destroy(); + } + } + + /** + * @return true + */ + public boolean init(int xpos, int ypos) { + // do nothing + window_xpos = xpos; + window_ypos = ypos; + return true; + } + + public void beginFrame(float camera_separation) { + // do nothing + } + + public void endFrame() { + glFlush(); + // swap buffers + Display.update(); + } + + public void appActivate(boolean activate) { + // do nothing + } + + public void enableLogging(boolean enable) { + // do nothing + } + + public void logNewFrame() { + // do nothing + } + + /** + * this is a hack for jogl renderers. + * + * @param callback + */ + public final void updateScreen(xcommand_t callback) { + callback.execute(); + } + +} diff --git a/src/jake2/render/opengl/LwjglGL.java b/src/jake2/render/opengl/LwjglGL.java new file mode 100644 index 0000000..5be7df4 --- /dev/null +++ b/src/jake2/render/opengl/LwjglGL.java @@ -0,0 +1,302 @@ +package jake2.render.opengl; + + + +import java.nio.*; + +import org.lwjgl.util.GL; + +public class LwjglGL implements QGL { + + LwjglGL() { + // singleton + } + + public final void glAlphaFunc(int func, float ref) { + GL.glAlphaFunc(func, ref); + } + + public final void glBegin(int mode) { + GL.glBegin(mode); + } + + public final void glBindTexture(int target, int texture) { + GL.glBindTexture(target, texture); + } + + public final void glBlendFunc(int sfactor, int dfactor) { + GL.glBlendFunc(sfactor, dfactor); + } + + public final void glClear(int mask) { + GL.glClear(mask); + } + + public final void glClearColor(float red, float green, float blue, float alpha) { + GL.glClearColor(red, green, blue, alpha); + } + + public final void glColor3f(float red, float green, float blue) { + GL.glColor3f(red, green, blue); + } + + public final void glColor3ub(byte red, byte green, byte blue) { + GL.glColor3ub(red, green, blue); + } + + public final void glColor4f(float red, float green, float blue, float alpha) { + GL.glColor4f(red, green, blue, alpha); + } + + public final void glColor4ub(byte red, byte green, byte blue, byte alpha) { + GL.glColor4ub(red, green, blue, alpha); + } + + public final void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer) { + GL.glColorPointer(size, unsigned, stride, pointer); + } + + public final void glColorPointer(int size, int stride, FloatBuffer pointer) { + GL.glColorPointer(size, stride, pointer); + } + + public final void glCullFace(int mode) { + GL.glCullFace(mode); + } + + public final void glDeleteTextures(IntBuffer textures) { + GL.glDeleteTextures(textures); + } + + public final void glDepthFunc(int func) { + GL.glDepthFunc(func); + } + + public final void glDepthMask(boolean flag) { + GL.glDepthMask(flag); + } + + public final void glDepthRange(double zNear, double zFar) { + GL.glDepthRange(zNear, zFar); + } + + public final void glDisable(int cap) { + GL.glDisable(cap); + } + + public final void glDisableClientState(int cap) { + GL.glDisableClientState(cap); + } + + public final void glDrawArrays(int mode, int first, int count) { + GL.glDrawArrays(mode, first, count); + } + + public final void glDrawBuffer(int mode) { + GL.glDrawBuffer(mode); + } + + public final void glDrawElements(int mode, IntBuffer indices) { + GL.glDrawElements(mode, indices); + } + + public final void glEnable(int cap) { + GL.glEnable(cap); + } + + public final void glEnableClientState(int cap) { + GL.glEnableClientState(cap); + } + + public final void glEnd() { + GL.glEnd(); + } + + public final void glFinish() { + GL.glFinish(); + } + + public final void glFlush() { + GL.glFlush(); + } + + public final void glFrustum(double left, double right, double bottom, + double top, double zNear, double zFar) { + GL.glFrustum(left, right, bottom, top, zNear, zFar); + } + + public final int glGetError() { + return GL.glGetError(); + } + + public final void glGetFloat(int pname, FloatBuffer params) { + GL.glGetFloat(pname, params); + } + + public final String glGetString(int name) { + return GL.glGetString(name); + } + + public final void glInterleavedArrays(int format, int stride, + FloatBuffer pointer) { + GL.glInterleavedArrays(format, stride, pointer); + } + + public final void glLoadIdentity() { + GL.glLoadIdentity(); + } + + public final void glLoadMatrix(FloatBuffer m) { + GL.glLoadMatrix(m); + } + + public final void glMatrixMode(int mode) { + GL.glMatrixMode(mode); + } + + public final void glOrtho(double left, double right, double bottom, + double top, double zNear, double zFar) { + GL.glOrtho(left, right, bottom, top, zNear, zFar); + } + + public final void glPixelStorei(int pname, int param) { + GL.glPixelStorei(pname, param); + } + + public final void glPointSize(float size) { + GL.glPointSize(size); + } + + public final void glPolygonMode(int face, int mode) { + GL.glPolygonMode(face, mode); + } + + public final void glPopMatrix() { + GL.glPopMatrix(); + } + + public final void glPushMatrix() { + GL.glPushMatrix(); + } + + public final void glReadPixels(int x, int y, int width, int height, + int format, int type, ByteBuffer pixels) { + GL.glReadPixels(x, y, width, height, format, type, pixels); + } + + public final void glRotatef(float angle, float x, float y, float z) { + GL.glRotatef(angle, x, y, z); + } + + public final void glScalef(float x, float y, float z) { + GL.glScalef(x, y, z); + } + + public final void glScissor(int x, int y, int width, int height) { + GL.glScissor(x, y, width, height); + } + + public final void glShadeModel(int mode) { + GL.glShadeModel(mode); + } + + public final void glTexCoord2f(float s, float t) { + GL.glTexCoord2f(s, t); + } + + public final void glTexCoordPointer(int size, int stride, FloatBuffer pointer) { + GL.glTexCoordPointer(size, stride, pointer); + } + + public final void glTexEnvi(int target, int pname, int param) { + GL.glTexEnvi(target, pname, param); + } + + public final void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + ByteBuffer pixels) { + GL.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + + public final void glTexImage2D(int target, int level, int internalformat, + int width, int height, int border, int format, int type, + IntBuffer pixels) { + GL.glTexImage2D(target, level, internalformat, width, height, border, + format, type, pixels); + } + + public final void glTexParameterf(int target, int pname, float param) { + GL.glTexParameterf(target, pname, param); + } + + public final void glTexParameteri(int target, int pname, int param) { + GL.glTexParameteri(target, pname, param); + } + + public final void glTexSubImage2D(int target, int level, int xoffset, + int yoffset, int width, int height, int format, int type, + IntBuffer pixels) { + GL.glTexSubImage2D(target, level, xoffset, yoffset, width, height, + format, type, pixels); + } + + public final void glTranslatef(float x, float y, float z) { + GL.glTranslatef(x, y, z); + } + + public final void glVertex2f(float x, float y) { + GL.glVertex2f(x, y); + } + + public final void glVertex3f(float x, float y, float z) { + GL.glVertex3f(x, y, z); + } + + public final void glVertexPointer(int size, int stride, FloatBuffer pointer) { + GL.glVertexPointer(size, stride, pointer); + } + + public final void glViewport(int x, int y, int width, int height) { + GL.glViewport(x, y, width, height); + } + + public final void glColorTable(int target, int internalFormat, int width, + int format, int type, ByteBuffer data) { + GL.glColorTable(target, internalFormat, width, format, type, data); + } + + public final void glActiveTextureARB(int texture) { + GL.glActiveTextureARB(texture); + } + + public final void glClientActiveTextureARB(int texture) { + GL.glClientActiveTextureARB(texture); + } + + public final void glPointParameterEXT(int pname, FloatBuffer pfParams) { + GL.glPointParameterEXT(pname, pfParams); + } + + public final void glPointParameterfEXT(int pname, float param) { + GL.glPointParameterfEXT(pname, param); + } + + public final void glLockArraysEXT(int first, int count) { + GL.glLockArraysEXT(first, count); + } + + public final void glArrayElement(int index) { + GL.glArrayElement(index); + } + + public final void glUnlockArraysEXT() { + GL.glUnlockArraysEXT(); + } + + public final void glMultiTexCoord2f(int target, float s, float t) { + GL.glMultiTexCoord2f(target, s, t); + } + +} diff --git a/src/jake2/render/opengl/QGL.java b/src/jake2/render/opengl/QGL.java new file mode 100644 index 0000000..ad79052 --- /dev/null +++ b/src/jake2/render/opengl/QGL.java @@ -0,0 +1,155 @@ +package jake2.render.opengl; + +import java.nio.*; + +public interface QGL extends QGLConst { + + /* + * a sub set of OpenGL for Jake2 + */ + + void glActiveTextureARB(int texture); + + void glAlphaFunc(int func, float ref); + + void glArrayElement(int index); + + void glBegin(int mode); + + void glBindTexture(int target, int texture); + + void glBlendFunc(int sfactor, int dfactor); + + void glClear(int mask); + + void glClearColor(float red, float green, float blue, float alpha); + + void glClientActiveTextureARB(int texture); + + void glColor3f(float red, float green, float blue); + + void glColor3ub(byte red, byte green, byte blue); + + void glColor4f(float red, float green, float blue, float alpha); + + void glColor4ub(byte red, byte green, byte blue, byte alpha); + + void glColorPointer(int size, boolean unsigned, int stride, + ByteBuffer pointer); + + void glColorPointer(int size, int stride, FloatBuffer pointer); + + void glColorTable(int target, int internalFormat, int width, int format, + int type, ByteBuffer data); + + void glCullFace(int mode); + + void glDeleteTextures(IntBuffer textures); + + void glDepthFunc(int func); + + void glDepthMask(boolean flag); + + void glDepthRange(double zNear, double zFar); + + void glDisable(int cap); + + void glDisableClientState(int cap); + + void glDrawArrays(int mode, int first, int count); + + void glDrawBuffer(int mode); + + void glDrawElements(int mode, IntBuffer indices); + + void glEnable(int cap); + + void glEnableClientState(int cap); + + void glEnd(); + + void glFinish(); + + void glFlush(); + + void glFrustum(double left, double right, double bottom, double top, + double zNear, double zFar); + + int glGetError(); + + void glGetFloat(int pname, FloatBuffer params); + + String glGetString(int name); + + void glInterleavedArrays(int format, int stride, FloatBuffer pointer); + + void glLockArraysEXT(int first, int count); + + void glLoadIdentity(); + + void glLoadMatrix(FloatBuffer m); + + void glMatrixMode(int mode); + + void glMultiTexCoord2f(int target, float s, float t); + + void glOrtho(double left, double right, double bottom, double top, + double zNear, double zFar); + + void glPixelStorei(int pname, int param); + + void glPointParameterEXT(int pname, FloatBuffer pfParams); + + void glPointParameterfEXT(int pname, float param); + + void glPointSize(float size); + + void glPolygonMode(int face, int mode); + + void glPopMatrix(); + + void glPushMatrix(); + + void glReadPixels(int x, int y, int width, int height, int format, + int type, ByteBuffer pixels); + + void glRotatef(float angle, float x, float y, float z); + + void glScalef(float x, float y, float z); + + void glScissor(int x, int y, int width, int height); + + void glShadeModel(int mode); + + void glTexCoord2f(float s, float t); + + void glTexCoordPointer(int size, int stride, FloatBuffer pointer); + + void glTexEnvi(int target, int pname, int param); + + void glTexImage2D(int target, int level, int internalformat, int width, + int height, int border, int format, int type, ByteBuffer pixels); + + void glTexImage2D(int target, int level, int internalformat, int width, + int height, int border, int format, int type, IntBuffer pixels); + + void glTexParameterf(int target, int pname, float param); + + void glTexParameteri(int target, int pname, int param); + + void glTexSubImage2D(int target, int level, int xoffset, int yoffset, + int width, int height, int format, int type, IntBuffer pixels); + + void glTranslatef(float x, float y, float z); + + void glUnlockArraysEXT(); + + void glVertex2f(float x, float y); + + void glVertex3f(float x, float y, float z); + + void glVertexPointer(int size, int stride, FloatBuffer pointer); + + void glViewport(int x, int y, int width, int height); + +}
\ No newline at end of file diff --git a/src/jake2/render/opengl/QGLConst.java b/src/jake2/render/opengl/QGLConst.java new file mode 100644 index 0000000..024abef --- /dev/null +++ b/src/jake2/render/opengl/QGLConst.java @@ -0,0 +1,308 @@ +package jake2.render.opengl; + + +public interface QGLConst { + + /* + * alpha functions + */ + public static final int GL_NEVER = 0x0200; + + public static final int GL_LESS = 0x0201; + + public static final int GL_EQUAL = 0x0202; + + public static final int GL_LEQUAL = 0x0203; + + public static final int GL_GREATER = 0x0204; + + public static final int GL_NOTEQUAL = 0x0205; + + public static final int GL_GEQUAL = 0x0206; + + public static final int GL_ALWAYS = 0x0207; + + /* + * attribute masks + */ + public static final int GL_DEPTH_BUFFER_BIT = 0x00000100; + + public static final int GL_STENCIL_BUFFER_BIT = 0x00000400; + + public static final int GL_COLOR_BUFFER_BIT = 0x00004000; + + /* + * begin modes + */ + public static final int GL_POINTS = 0x0000; + + public static final int GL_LINES = 0x0001; + + public static final int GL_LINE_LOOP = 0x0002; + + public static final int GL_LINE_STRIP = 0x0003; + + public static final int GL_TRIANGLES = 0x0004; + + public static final int GL_TRIANGLE_STRIP = 0x0005; + + public static final int GL_TRIANGLE_FAN = 0x0006; + + public static final int GL_QUADS = 0x0007; + + public static final int GL_QUAD_STRIP = 0x0008; + + public static final int GL_POLYGON = 0x0009; + + /* + * blending factors + */ + public static final int GL_ZERO = 0; + + public static final int GL_ONE = 1; + + public static final int GL_SRC_COLOR = 0x0300; + + public static final int GL_ONE_MINUS_SRC_COLOR = 0x0301; + + public static final int GL_SRC_ALPHA = 0x0302; + + public static final int GL_ONE_MINUS_SRC_ALPHA = 0x0303; + + public static final int GL_DST_ALPHA = 0x0304; + + public static final int GL_ONE_MINUS_DST_ALPHA = 0x0305; + + /* + * boolean + */ + public static final int GL_TRUE = 1; + + public static final int GL_FALSE = 0; + + /* + * data types + */ + public static final int GL_BYTE = 0x1400; + + public static final int GL_UNSIGNED_BYTE = 0x1401; + + public static final int GL_SHORT = 0x1402; + + public static final int GL_UNSIGNED_SHORT = 0x1403; + + public static final int GL_INT = 0x1404; + + public static final int GL_UNSIGNED_INT = 0x1405; + + public static final int GL_FLOAT = 0x1406; + + /* + * draw buffer modes + */ + public static final int GL_FRONT = 0x0404; + + public static final int GL_BACK = 0x0405; + + public static final int GL_FRONT_AND_BACK = 0x0408; + + /* + * errors + */ + public static final int GL_NO_ERROR = 0; + + public static final int GL_POINT_SMOOTH = 0x0B10; + + public static final int GL_CULL_FACE = 0x0B44; + + public static final int GL_DEPTH_TEST = 0x0B71; + + public static final int GL_MODELVIEW_MATRIX = 0x0BA6; + + public static final int GL_ALPHA_TEST = 0x0BC0; + + public static final int GL_BLEND = 0x0BE2; + + public static final int GL_SCISSOR_TEST = 0x0C11; + + public static final int GL_PACK_ALIGNMENT = 0x0D05; + + public static final int GL_TEXTURE_2D = 0x0DE1; + + /* + * hint modes + */ + public static final int GL_DONT_CARE = 0x1100; + + public static final int GL_FASTEST = 0x1101; + + public static final int GL_NICEST = 0x1102; + + /* + * matrix modes + */ + public static final int GL_MODELVIEW = 0x1700; + + public static final int GL_PROJECTION = 0x1701; + + /* + * pixel formats + */ + public static final int GL_COLOR_INDEX = 0x1900; + + public static final int GL_RED = 0x1903; + + public static final int GL_GREEN = 0x1904; + + public static final int GL_BLUE = 0x1905; + + public static final int GL_ALPHA = 0x1906; + + public static final int GL_RGB = 0x1907; + + public static final int GL_RGBA = 0x1908; + + public static final int GL_LUMINANCE = 0x1909; + + public static final int GL_LUMINANCE_ALPHA = 0x190A; + + /* + * polygon modes + */ + + public static final int GL_POINT = 0x1B00; + + public static final int GL_LINE = 0x1B01; + + public static final int GL_FILL = 0x1B02; + + /* + * shading models + */ + public static final int GL_FLAT = 0x1D00; + + public static final int GL_SMOOTH = 0x1D01; + + public static final int GL_REPLACE = 0x1E01; + + /* + * string names + */ + public static final int GL_VENDOR = 0x1F00; + + public static final int GL_RENDERER = 0x1F01; + + public static final int GL_VERSION = 0x1F02; + + public static final int GL_EXTENSIONS = 0x1F03; + + /* + * TextureEnvMode + */ + public static final int GL_MODULATE = 0x2100; + + /* + * TextureEnvParameter + */ + public static final int GL_TEXTURE_ENV_MODE = 0x2200; + + public static final int GL_TEXTURE_ENV_COLOR = 0x2201; + + /* + * TextureEnvTarget + */ + public static final int GL_TEXTURE_ENV = 0x2300; + + public static final int GL_NEAREST = 0x2600; + + public static final int GL_LINEAR = 0x2601; + + public static final int GL_NEAREST_MIPMAP_NEAREST = 0x2700; + + public static final int GL_LINEAR_MIPMAP_NEAREST = 0x2701; + + public static final int GL_NEAREST_MIPMAP_LINEAR = 0x2702; + + public static final int GL_LINEAR_MIPMAP_LINEAR = 0x2703; + + /* + * TextureParameterName + */ + public static final int GL_TEXTURE_MAG_FILTER = 0x2800; + + public static final int GL_TEXTURE_MIN_FILTER = 0x2801; + + public static final int GL_TEXTURE_WRAP_S = 0x2802; + + public static final int GL_TEXTURE_WRAP_T = 0x2803; + + /* + * TextureWrapMode + */ + public static final int GL_CLAMP = 0x2900; + + public static final int GL_REPEAT = 0x2901; + + /* + * texture + */ + public static final int GL_LUMINANCE8 = 0x8040; + + public static final int GL_INTENSITY8 = 0x804B; + + public static final int GL_R3_G3_B2 = 0x2A10; + + public static final int GL_RGB4 = 0x804F; + + public static final int GL_RGB5 = 0x8050; + + public static final int GL_RGB8 = 0x8051; + + public static final int GL_RGBA2 = 0x8055; + + public static final int GL_RGBA4 = 0x8056; + + public static final int GL_RGB5_A1 = 0x8057; + + public static final int GL_RGBA8 = 0x8058; + + /* + * vertex arrays + */ + public static final int GL_VERTEX_ARRAY = 0x8074; + + public static final int GL_COLOR_ARRAY = 0x8076; + + public static final int GL_TEXTURE_COORD_ARRAY = 0x8078; + + public static final int GL_T2F_V3F = 0x2A27; + + /* + * OpenGL 1.2, 1.3 constants + */ + public static final int GL_SHARED_TEXTURE_PALETTE_EXT = 0x81FB; + + public static final int GL_TEXTURE0 = 0x84C0; + + public static final int GL_TEXTURE1 = 0x84C1; + + public static final int GL_TEXTURE0_ARB = 0x84C0; + + public static final int GL_TEXTURE1_ARB = 0x84C1; + + public static final int GL_BGR = 0x80E0; + + public static final int GL_BGRA = 0x80E1; + + /* + * point parameters + */ + public static final int GL_POINT_SIZE_MIN_EXT = 0x8126; + + public static final int GL_POINT_SIZE_MAX_EXT = 0x8127; + + public static final int GL_POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128; + + public static final int GL_DISTANCE_ATTENUATION_EXT = 0x8129; + +}
\ No newline at end of file |