2004-03-22 22:02:18 +00:00
|
|
|
/**
|
|
|
|
* $Id$
|
2008-04-16 22:40:48 +00:00
|
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
2004-03-22 22:02:18 +00:00
|
|
|
*
|
|
|
|
* 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
|
2008-04-16 22:40:48 +00:00
|
|
|
* of the License, or (at your option) any later version.
|
2004-03-22 22:02:18 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* The Original Code is: all of this file.
|
|
|
|
*
|
|
|
|
* Contributor(s): none yet.
|
|
|
|
*
|
2008-04-16 22:40:48 +00:00
|
|
|
* ***** END GPL LICENSE BLOCK *****
|
2004-03-22 22:02:18 +00:00
|
|
|
*/
|
2004-10-24 23:50:44 +00:00
|
|
|
|
|
|
|
#include <math.h>
|
2008-04-16 17:40:59 +00:00
|
|
|
#include <stdlib.h>
|
2004-10-24 23:50:44 +00:00
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
#include "RAS_OpenGLRasterizer.h"
|
|
|
|
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
#include "GL/glew.h"
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
#include "RAS_Rect.h"
|
|
|
|
#include "RAS_TexVert.h"
|
2009-06-08 20:08:19 +00:00
|
|
|
#include "RAS_MeshObject.h"
|
2002-10-12 11:37:38 +00:00
|
|
|
#include "MT_CmMatrix4x4.h"
|
|
|
|
#include "RAS_IRenderTools.h" // rendering text
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
#include "GPU_draw.h"
|
|
|
|
#include "GPU_material.h"
|
2009-06-08 20:08:19 +00:00
|
|
|
#include "GPU_extensions.h"
|
|
|
|
|
|
|
|
#include "DNA_image_types.h"
|
|
|
|
#include "DNA_meshdata_types.h"
|
|
|
|
#include "DNA_material_types.h"
|
|
|
|
#include "DNA_scene_types.h"
|
|
|
|
|
|
|
|
#include "BKE_DerivedMesh.h"
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
2004-10-24 23:50:44 +00:00
|
|
|
/**
|
|
|
|
* 32x32 bit masks for vinterlace stereo mode
|
|
|
|
*/
|
|
|
|
static GLuint left_eye_vinterlace_mask[32];
|
|
|
|
static GLuint right_eye_vinterlace_mask[32];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 32x32 bit masks for hinterlace stereo mode.
|
|
|
|
* Left eye = &hinterlace_mask[0]
|
|
|
|
* Right eye = &hinterlace_mask[1]
|
|
|
|
*/
|
|
|
|
static GLuint hinterlace_mask[33];
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas)
|
|
|
|
:RAS_IRasterizer(canvas),
|
|
|
|
m_2DCanvas(canvas),
|
|
|
|
m_fogenabled(false),
|
2004-08-10 11:34:12 +00:00
|
|
|
m_time(0.0),
|
2009-02-06 19:21:24 +00:00
|
|
|
m_campos(0.0f, 0.0f, 0.0f),
|
|
|
|
m_camortho(false),
|
2004-08-10 11:34:12 +00:00
|
|
|
m_stereomode(RAS_STEREO_NOSTEREO),
|
|
|
|
m_curreye(RAS_STEREO_LEFTEYE),
|
2004-10-24 23:50:44 +00:00
|
|
|
m_eyeseparation(0.0),
|
|
|
|
m_seteyesep(false),
|
|
|
|
m_focallength(0.0),
|
|
|
|
m_setfocallength(false),
|
2004-03-22 22:02:18 +00:00
|
|
|
m_noOfScanlines(32),
|
2007-09-29 18:51:01 +00:00
|
|
|
m_motionblur(0),
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
m_motionblurvalue(-1.0),
|
|
|
|
m_texco_num(0),
|
|
|
|
m_attrib_num(0),
|
2009-06-08 20:08:19 +00:00
|
|
|
//m_last_blendmode(GPU_BLEND_SOLID),
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
m_last_frontface(true),
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
m_materialCachingInfo(0)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
m_viewmatrix.setIdentity();
|
|
|
|
m_viewinvmatrix.setIdentity();
|
2004-10-24 23:50:44 +00:00
|
|
|
|
|
|
|
for (int i = 0; i < 32; i++)
|
|
|
|
{
|
|
|
|
left_eye_vinterlace_mask[i] = 0x55555555;
|
|
|
|
right_eye_vinterlace_mask[i] = 0xAAAAAAAA;
|
|
|
|
hinterlace_mask[i] = (i&1)*0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
hinterlace_mask[32] = 0;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
RAS_OpenGLRasterizer::~RAS_OpenGLRasterizer()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
bool RAS_OpenGLRasterizer::Init()
|
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
GPU_state_init();
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
m_redback = 0.4375;
|
|
|
|
m_greenback = 0.4375;
|
|
|
|
m_blueback = 0.4375;
|
|
|
|
m_alphaback = 0.0;
|
|
|
|
|
2006-01-06 03:46:54 +00:00
|
|
|
m_ambr = 0.0f;
|
|
|
|
m_ambg = 0.0f;
|
|
|
|
m_ambb = 0.0f;
|
|
|
|
|
2008-09-14 00:32:18 +00:00
|
|
|
glDisable(GL_BLEND);
|
|
|
|
glDisable(GL_ALPHA_TEST);
|
2009-06-08 20:08:19 +00:00
|
|
|
//m_last_blendmode = GPU_BLEND_SOLID;
|
|
|
|
GPU_set_material_blend_mode(GPU_BLEND_SOLID);
|
2008-09-14 00:32:18 +00:00
|
|
|
|
|
|
|
glFrontFace(GL_CCW);
|
|
|
|
m_last_frontface = true;
|
2008-07-29 15:48:31 +00:00
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
glClearColor(m_redback,m_greenback,m_blueback,m_alphaback);
|
2004-08-10 11:34:12 +00:00
|
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
2002-10-12 11:37:38 +00:00
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
|
|
|
|
glShadeModel(GL_SMOOTH);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-01-06 03:46:54 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetAmbientColor(float red, float green, float blue)
|
|
|
|
{
|
|
|
|
m_ambr = red;
|
|
|
|
m_ambg = green;
|
|
|
|
m_ambb = blue;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetAmbient(float factor)
|
|
|
|
{
|
|
|
|
float ambient[] = { m_ambr*factor, m_ambg*factor, m_ambb*factor, 1.0f };
|
|
|
|
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
|
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetBackColor(float red,
|
|
|
|
float green,
|
|
|
|
float blue,
|
|
|
|
float alpha)
|
|
|
|
{
|
|
|
|
m_redback = red;
|
|
|
|
m_greenback = green;
|
|
|
|
m_blueback = blue;
|
|
|
|
m_alphaback = alpha;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetFogColor(float r,
|
|
|
|
float g,
|
|
|
|
float b)
|
|
|
|
{
|
|
|
|
m_fogr = r;
|
|
|
|
m_fogg = g;
|
|
|
|
m_fogb = b;
|
|
|
|
m_fogenabled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetFogStart(float start)
|
|
|
|
{
|
|
|
|
m_fogstart = start;
|
|
|
|
m_fogenabled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetFogEnd(float fogend)
|
|
|
|
{
|
|
|
|
m_fogdist = fogend;
|
|
|
|
m_fogenabled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetFog(float start,
|
|
|
|
float dist,
|
|
|
|
float r,
|
|
|
|
float g,
|
|
|
|
float b)
|
|
|
|
{
|
|
|
|
m_fogstart = start;
|
|
|
|
m_fogdist = dist;
|
|
|
|
m_fogr = r;
|
|
|
|
m_fogg = g;
|
|
|
|
m_fogb = b;
|
|
|
|
m_fogenabled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::DisableFog()
|
|
|
|
{
|
|
|
|
m_fogenabled = false;
|
|
|
|
}
|
|
|
|
|
2009-06-08 20:08:19 +00:00
|
|
|
bool RAS_OpenGLRasterizer::IsFogEnabled()
|
|
|
|
{
|
|
|
|
return m_fogenabled;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::DisplayFog()
|
|
|
|
{
|
|
|
|
if ((m_drawingmode >= KX_SOLID) && m_fogenabled)
|
|
|
|
{
|
|
|
|
float params[5];
|
|
|
|
glFogi(GL_FOG_MODE, GL_LINEAR);
|
|
|
|
glFogf(GL_FOG_DENSITY, 0.1f);
|
|
|
|
glFogf(GL_FOG_START, m_fogstart);
|
|
|
|
glFogf(GL_FOG_END, m_fogstart + m_fogdist);
|
|
|
|
params[0]= m_fogr;
|
|
|
|
params[1]= m_fogg;
|
|
|
|
params[2]= m_fogb;
|
|
|
|
params[3]= 0.0;
|
|
|
|
glFogfv(GL_FOG_COLOR, params);
|
|
|
|
glEnable(GL_FOG);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
glDisable(GL_FOG);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-01-16 06:02:06 +00:00
|
|
|
bool RAS_OpenGLRasterizer::SetMaterial(const RAS_IPolyMaterial& mat)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
2005-01-16 06:02:06 +00:00
|
|
|
return mat.Activate(this, m_materialCachingInfo);
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::Exit()
|
|
|
|
{
|
|
|
|
|
|
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
glClearDepth(1.0);
|
2004-08-10 11:34:12 +00:00
|
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
2002-10-12 11:37:38 +00:00
|
|
|
glClearColor(m_redback, m_greenback, m_blueback, m_alphaback);
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
2004-04-11 02:50:02 +00:00
|
|
|
glDepthMask (GL_TRUE);
|
2002-10-12 11:37:38 +00:00
|
|
|
glDepthFunc(GL_LEQUAL);
|
|
|
|
glBlendFunc(GL_ONE, GL_ZERO);
|
2004-10-24 11:03:18 +00:00
|
|
|
|
|
|
|
glDisable(GL_POLYGON_STIPPLE);
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
glDisable(GL_LIGHTING);
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
if (GLEW_EXT_separate_specular_color || GLEW_VERSION_1_2)
|
2004-06-07 11:01:31 +00:00
|
|
|
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
EndFrame();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool RAS_OpenGLRasterizer::BeginFrame(int drawingmode, double time)
|
|
|
|
{
|
|
|
|
m_time = time;
|
|
|
|
m_drawingmode = drawingmode;
|
|
|
|
|
|
|
|
// Blender camera routine destroys the settings
|
|
|
|
if (m_drawingmode < KX_SOLID)
|
|
|
|
{
|
|
|
|
glDisable (GL_CULL_FACE);
|
|
|
|
glDisable (GL_DEPTH_TEST);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
glEnable (GL_CULL_FACE);
|
|
|
|
}
|
|
|
|
|
2008-09-14 00:32:18 +00:00
|
|
|
glDisable(GL_BLEND);
|
|
|
|
glDisable(GL_ALPHA_TEST);
|
2009-06-08 20:08:19 +00:00
|
|
|
//m_last_blendmode = GPU_BLEND_SOLID;
|
|
|
|
GPU_set_material_blend_mode(GPU_BLEND_SOLID);
|
2008-09-14 00:32:18 +00:00
|
|
|
|
|
|
|
glFrontFace(GL_CCW);
|
|
|
|
m_last_frontface = true;
|
2008-07-29 15:48:31 +00:00
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
glShadeModel(GL_SMOOTH);
|
|
|
|
|
2004-04-11 02:50:02 +00:00
|
|
|
m_2DCanvas->BeginFrame();
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetDrawingMode(int drawingmode)
|
|
|
|
{
|
|
|
|
m_drawingmode = drawingmode;
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
if(m_drawingmode == KX_WIREFRAME)
|
|
|
|
glDisable(GL_CULL_FACE);
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int RAS_OpenGLRasterizer::GetDrawingMode()
|
|
|
|
{
|
|
|
|
return m_drawingmode;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-08-10 11:34:12 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetDepthMask(DepthMask depthmask)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
2004-08-10 11:34:12 +00:00
|
|
|
glDepthMask(depthmask == KX_DEPTHMASK_DISABLED ? GL_FALSE : GL_TRUE);
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-09-14 00:32:18 +00:00
|
|
|
void RAS_OpenGLRasterizer::ClearColorBuffer()
|
|
|
|
{
|
|
|
|
m_2DCanvas->ClearColor(m_redback,m_greenback,m_blueback,m_alphaback);
|
|
|
|
m_2DCanvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER);
|
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::ClearDepthBuffer()
|
|
|
|
{
|
|
|
|
m_2DCanvas->ClearBuffer(RAS_ICanvas::DEPTH_BUFFER);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::ClearCachingInfo(void)
|
|
|
|
{
|
|
|
|
m_materialCachingInfo = 0;
|
|
|
|
}
|
|
|
|
|
2009-04-20 15:06:46 +00:00
|
|
|
void RAS_OpenGLRasterizer::FlushDebugLines()
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
2009-04-20 15:06:46 +00:00
|
|
|
if(!m_debugLines.size())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// DrawDebugLines
|
|
|
|
GLboolean light, tex;
|
|
|
|
|
|
|
|
light= glIsEnabled(GL_LIGHTING);
|
|
|
|
tex= glIsEnabled(GL_TEXTURE_2D);
|
|
|
|
|
|
|
|
if(light) glDisable(GL_LIGHTING);
|
|
|
|
if(tex) glDisable(GL_TEXTURE_2D);
|
2005-08-04 19:07:39 +00:00
|
|
|
|
2005-07-27 09:30:53 +00:00
|
|
|
glBegin(GL_LINES);
|
|
|
|
for (unsigned int i=0;i<m_debugLines.size();i++)
|
|
|
|
{
|
|
|
|
glColor4f(m_debugLines[i].m_color[0],m_debugLines[i].m_color[1],m_debugLines[i].m_color[2],1.f);
|
|
|
|
const MT_Scalar* fromPtr = &m_debugLines[i].m_from.x();
|
|
|
|
const MT_Scalar* toPtr= &m_debugLines[i].m_to.x();
|
|
|
|
|
|
|
|
glVertex3dv(fromPtr);
|
|
|
|
glVertex3dv(toPtr);
|
|
|
|
}
|
|
|
|
glEnd();
|
|
|
|
|
2009-04-20 15:06:46 +00:00
|
|
|
if(light) glEnable(GL_LIGHTING);
|
|
|
|
if(tex) glEnable(GL_TEXTURE_2D);
|
2009-03-09 05:01:16 +00:00
|
|
|
|
2005-07-27 09:30:53 +00:00
|
|
|
m_debugLines.clear();
|
2009-03-09 05:01:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::EndFrame()
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
FlushDebugLines();
|
|
|
|
|
2004-08-10 11:34:12 +00:00
|
|
|
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
2002-10-12 11:37:38 +00:00
|
|
|
m_2DCanvas->EndFrame();
|
|
|
|
}
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetRenderArea()
|
|
|
|
{
|
|
|
|
// only above/below stereo method needs viewport adjustment
|
2004-08-10 11:34:12 +00:00
|
|
|
switch (m_stereomode)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
2004-08-10 11:34:12 +00:00
|
|
|
case RAS_STEREO_ABOVEBELOW:
|
|
|
|
switch(m_curreye)
|
|
|
|
{
|
|
|
|
case RAS_STEREO_LEFTEYE:
|
|
|
|
// upper half of window
|
|
|
|
m_2DCanvas->GetDisplayArea().SetLeft(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetBottom(m_2DCanvas->GetHeight() -
|
|
|
|
int(m_2DCanvas->GetHeight() - m_noOfScanlines) / 2);
|
|
|
|
|
|
|
|
m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
|
|
|
|
m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight()));
|
|
|
|
break;
|
|
|
|
case RAS_STEREO_RIGHTEYE:
|
|
|
|
// lower half of window
|
|
|
|
m_2DCanvas->GetDisplayArea().SetLeft(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetBottom(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
|
|
|
|
m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight() - m_noOfScanlines) / 2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RAS_STEREO_SIDEBYSIDE:
|
|
|
|
switch (m_curreye)
|
|
|
|
{
|
|
|
|
case RAS_STEREO_LEFTEYE:
|
|
|
|
// Left half of window
|
|
|
|
m_2DCanvas->GetDisplayArea().SetLeft(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetBottom(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetRight(m_2DCanvas->GetWidth()/2);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetTop(m_2DCanvas->GetHeight());
|
|
|
|
break;
|
|
|
|
case RAS_STEREO_RIGHTEYE:
|
|
|
|
// Right half of window
|
|
|
|
m_2DCanvas->GetDisplayArea().SetLeft(m_2DCanvas->GetWidth()/2);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetBottom(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetRight(m_2DCanvas->GetWidth());
|
|
|
|
m_2DCanvas->GetDisplayArea().SetTop(m_2DCanvas->GetHeight());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// every available pixel
|
|
|
|
m_2DCanvas->GetDisplayArea().SetLeft(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetBottom(0);
|
|
|
|
m_2DCanvas->GetDisplayArea().SetRight(int(m_2DCanvas->GetWidth()));
|
|
|
|
m_2DCanvas->GetDisplayArea().SetTop(int(m_2DCanvas->GetHeight()));
|
|
|
|
break;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-08-10 11:34:12 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetStereoMode(const StereoMode stereomode)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
|
|
|
m_stereomode = stereomode;
|
|
|
|
}
|
|
|
|
|
2008-11-26 17:38:54 +00:00
|
|
|
RAS_IRasterizer::StereoMode RAS_OpenGLRasterizer::GetStereoMode()
|
|
|
|
{
|
|
|
|
return m_stereomode;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
bool RAS_OpenGLRasterizer::Stereo()
|
|
|
|
{
|
2009-07-20 20:28:29 +00:00
|
|
|
if(m_stereomode > RAS_STEREO_NOSTEREO) // > 0
|
2002-10-12 11:37:38 +00:00
|
|
|
return true;
|
2009-07-20 20:28:29 +00:00
|
|
|
else
|
|
|
|
return false;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
2008-09-14 00:32:18 +00:00
|
|
|
bool RAS_OpenGLRasterizer::InterlacedStereo()
|
|
|
|
{
|
|
|
|
return m_stereomode == RAS_STEREO_VINTERLACE || m_stereomode == RAS_STEREO_INTERLACED;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2006-11-25 16:35:56 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetEye(const StereoEye eye)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
|
|
|
m_curreye = eye;
|
2004-08-10 11:34:12 +00:00
|
|
|
switch (m_stereomode)
|
|
|
|
{
|
|
|
|
case RAS_STEREO_QUADBUFFERED:
|
|
|
|
glDrawBuffer(m_curreye == RAS_STEREO_LEFTEYE ? GL_BACK_LEFT : GL_BACK_RIGHT);
|
|
|
|
break;
|
|
|
|
case RAS_STEREO_ANAGLYPH:
|
|
|
|
if (m_curreye == RAS_STEREO_LEFTEYE)
|
|
|
|
{
|
|
|
|
glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);
|
|
|
|
} else {
|
2004-10-16 11:41:50 +00:00
|
|
|
//glAccum(GL_LOAD, 1.0);
|
2004-08-10 11:34:12 +00:00
|
|
|
glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE);
|
|
|
|
ClearDepthBuffer();
|
|
|
|
}
|
|
|
|
break;
|
2004-10-24 11:03:18 +00:00
|
|
|
case RAS_STEREO_VINTERLACE:
|
|
|
|
{
|
|
|
|
glEnable(GL_POLYGON_STIPPLE);
|
2004-10-24 23:50:44 +00:00
|
|
|
glPolygonStipple((const GLubyte*) ((m_curreye == RAS_STEREO_LEFTEYE) ? left_eye_vinterlace_mask : right_eye_vinterlace_mask));
|
2004-10-24 11:03:18 +00:00
|
|
|
if (m_curreye == RAS_STEREO_RIGHTEYE)
|
|
|
|
ClearDepthBuffer();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case RAS_STEREO_INTERLACED:
|
|
|
|
{
|
|
|
|
glEnable(GL_POLYGON_STIPPLE);
|
2004-10-24 23:50:44 +00:00
|
|
|
glPolygonStipple((const GLubyte*) &hinterlace_mask[m_curreye == RAS_STEREO_LEFTEYE?0:1]);
|
2004-10-24 11:03:18 +00:00
|
|
|
if (m_curreye == RAS_STEREO_RIGHTEYE)
|
|
|
|
ClearDepthBuffer();
|
|
|
|
break;
|
|
|
|
}
|
2004-08-10 11:34:12 +00:00
|
|
|
default:
|
|
|
|
break;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-10-24 11:03:18 +00:00
|
|
|
RAS_IRasterizer::StereoEye RAS_OpenGLRasterizer::GetEye()
|
|
|
|
{
|
|
|
|
return m_curreye;
|
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2006-11-25 16:35:56 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetEyeSeparation(const float eyeseparation)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
|
|
|
m_eyeseparation = eyeseparation;
|
2004-10-24 23:50:44 +00:00
|
|
|
m_seteyesep = true;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
2004-10-24 11:03:18 +00:00
|
|
|
float RAS_OpenGLRasterizer::GetEyeSeparation()
|
|
|
|
{
|
|
|
|
return m_eyeseparation;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2006-11-25 16:35:56 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetFocalLength(const float focallength)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
|
|
|
m_focallength = focallength;
|
2004-10-24 23:50:44 +00:00
|
|
|
m_setfocallength = true;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
2004-10-24 11:03:18 +00:00
|
|
|
float RAS_OpenGLRasterizer::GetFocalLength()
|
|
|
|
{
|
|
|
|
return m_focallength;
|
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SwapBuffers()
|
|
|
|
{
|
|
|
|
m_2DCanvas->SwapBuffers();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
const MT_Matrix4x4& RAS_OpenGLRasterizer::GetViewMatrix() const
|
2006-02-13 05:45:32 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
return m_viewmatrix;
|
2006-02-13 05:45:32 +00:00
|
|
|
}
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
const MT_Matrix4x4& RAS_OpenGLRasterizer::GetViewInvMatrix() const
|
|
|
|
{
|
|
|
|
return m_viewinvmatrix;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
void RAS_OpenGLRasterizer::IndexPrimitives_3DText(RAS_MeshSlot& ms,
|
2002-10-12 11:37:38 +00:00
|
|
|
class RAS_IPolyMaterial* polymat,
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
class RAS_IRenderTools* rendertools)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
bool obcolor = ms.m_bObjectColor;
|
|
|
|
MT_Vector4& rgba = ms.m_RGBAcolor;
|
|
|
|
RAS_MeshSlot::iterator it;
|
|
|
|
|
|
|
|
// handle object color
|
|
|
|
if (obcolor) {
|
2002-10-12 11:37:38 +00:00
|
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
glEnableClientState(GL_COLOR_ARRAY);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
for(ms.begin(it); !ms.end(it); ms.next(it)) {
|
|
|
|
RAS_TexVert *vertex;
|
|
|
|
size_t i, j, numvert;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
numvert = it.array->m_type;
|
|
|
|
|
|
|
|
if(it.array->m_type == RAS_DisplayArray::LINE) {
|
|
|
|
// line drawing, no text
|
|
|
|
glBegin(GL_LINES);
|
|
|
|
|
|
|
|
for(i=0; i<it.totindex; i+=2)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
vertex = &it.vertex[it.index[i]];
|
|
|
|
glVertex3fv(vertex->getXYZ());
|
|
|
|
|
|
|
|
vertex = &it.vertex[it.index[i+1]];
|
|
|
|
glVertex3fv(vertex->getXYZ());
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
glEnd();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// triangle and quad text drawing
|
|
|
|
for(i=0; i<it.totindex; i+=numvert)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
float v[4][3];
|
|
|
|
int glattrib, unit;
|
|
|
|
|
|
|
|
for(j=0; j<numvert; j++) {
|
|
|
|
vertex = &it.vertex[it.index[i+j]];
|
|
|
|
|
|
|
|
v[j][0] = vertex->getXYZ()[0];
|
|
|
|
v[j][1] = vertex->getXYZ()[1];
|
|
|
|
v[j][2] = vertex->getXYZ()[2];
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
// find the right opengl attribute
|
|
|
|
glattrib = -1;
|
|
|
|
if(GLEW_ARB_vertex_program)
|
|
|
|
for(unit=0; unit<m_attrib_num; unit++)
|
|
|
|
if(m_attrib[unit] == RAS_TEXCO_UV1)
|
|
|
|
glattrib = unit;
|
|
|
|
|
|
|
|
rendertools->RenderText(polymat->GetDrawingMode(), polymat,
|
|
|
|
v[0], v[1], v[2], (numvert == 4)? v[3]: NULL, glattrib);
|
|
|
|
|
|
|
|
ClearCachingInfo();
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
glDisableClientState(GL_COLOR_ARRAY);
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetTexCoordNum(int num)
|
|
|
|
{
|
|
|
|
m_texco_num = num;
|
|
|
|
if(m_texco_num > RAS_MAX_TEXCO)
|
|
|
|
m_texco_num = RAS_MAX_TEXCO;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetAttribNum(int num)
|
|
|
|
{
|
|
|
|
m_attrib_num = num;
|
|
|
|
if(m_attrib_num > RAS_MAX_ATTRIB)
|
|
|
|
m_attrib_num = RAS_MAX_ATTRIB;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetTexCoord(TexCoGen coords, int unit)
|
2006-02-13 05:45:32 +00:00
|
|
|
{
|
|
|
|
// this changes from material to material
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
if(unit < RAS_MAX_TEXCO)
|
2006-02-13 05:45:32 +00:00
|
|
|
m_texco[unit] = coords;
|
|
|
|
}
|
|
|
|
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetAttrib(TexCoGen coords, int unit)
|
2006-04-11 05:57:30 +00:00
|
|
|
{
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
// this changes from material to material
|
|
|
|
if(unit < RAS_MAX_ATTRIB)
|
|
|
|
m_attrib[unit] = coords;
|
2006-04-11 05:57:30 +00:00
|
|
|
}
|
2006-02-13 05:45:32 +00:00
|
|
|
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
void RAS_OpenGLRasterizer::TexCoord(const RAS_TexVert &tv)
|
2006-02-13 05:45:32 +00:00
|
|
|
{
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
int unit;
|
|
|
|
|
|
|
|
if(GLEW_ARB_multitexture) {
|
|
|
|
for(unit=0; unit<m_texco_num; unit++) {
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
if(tv.getFlag() & RAS_TexVert::SECOND_UV && (int)tv.getUnit() == unit) {
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, tv.getUV2());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
switch(m_texco[unit]) {
|
|
|
|
case RAS_TEXCO_ORCO:
|
|
|
|
case RAS_TEXCO_GLOB:
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
glMultiTexCoord3fvARB(GL_TEXTURE0_ARB+unit, tv.getXYZ());
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
break;
|
|
|
|
case RAS_TEXCO_UV1:
|
|
|
|
glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, tv.getUV1());
|
|
|
|
break;
|
|
|
|
case RAS_TEXCO_NORM:
|
|
|
|
glMultiTexCoord3fvARB(GL_TEXTURE0_ARB+unit, tv.getNormal());
|
|
|
|
break;
|
|
|
|
case RAS_TEXTANGENT:
|
|
|
|
glMultiTexCoord4fvARB(GL_TEXTURE0_ARB+unit, tv.getTangent());
|
|
|
|
break;
|
|
|
|
case RAS_TEXCO_UV2:
|
|
|
|
glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, tv.getUV2());
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2006-02-13 05:45:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-04-11 05:57:30 +00:00
|
|
|
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
if(GLEW_ARB_vertex_program) {
|
|
|
|
for(unit=0; unit<m_attrib_num; unit++) {
|
|
|
|
switch(m_attrib[unit]) {
|
|
|
|
case RAS_TEXCO_ORCO:
|
|
|
|
case RAS_TEXCO_GLOB:
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
glVertexAttrib3fvARB(unit, tv.getXYZ());
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
break;
|
|
|
|
case RAS_TEXCO_UV1:
|
|
|
|
glVertexAttrib2fvARB(unit, tv.getUV1());
|
|
|
|
break;
|
|
|
|
case RAS_TEXCO_NORM:
|
|
|
|
glVertexAttrib3fvARB(unit, tv.getNormal());
|
|
|
|
break;
|
|
|
|
case RAS_TEXTANGENT:
|
|
|
|
glVertexAttrib4fvARB(unit, tv.getTangent());
|
|
|
|
break;
|
|
|
|
case RAS_TEXCO_UV2:
|
|
|
|
glVertexAttrib2fvARB(unit, tv.getUV2());
|
|
|
|
break;
|
2008-07-10 12:47:20 +00:00
|
|
|
case RAS_TEXCO_VCOL:
|
|
|
|
glVertexAttrib4ubvARB(unit, tv.getRGBA());
|
|
|
|
break;
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-04-11 05:57:30 +00:00
|
|
|
|
2006-04-02 21:04:20 +00:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::IndexPrimitives(RAS_MeshSlot& ms)
|
2006-04-02 21:04:20 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
IndexPrimitivesInternal(ms, false);
|
2006-02-13 05:45:32 +00:00
|
|
|
}
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
void RAS_OpenGLRasterizer::IndexPrimitivesMulti(RAS_MeshSlot& ms)
|
|
|
|
{
|
|
|
|
IndexPrimitivesInternal(ms, true);
|
|
|
|
}
|
2006-02-13 05:45:32 +00:00
|
|
|
|
2009-06-08 20:08:19 +00:00
|
|
|
static bool current_wireframe;
|
|
|
|
static RAS_MaterialBucket *current_bucket;
|
|
|
|
static RAS_IPolyMaterial *current_polymat;
|
|
|
|
static RAS_MeshSlot *current_ms;
|
|
|
|
static RAS_MeshObject *current_mesh;
|
|
|
|
static int current_blmat_nr;
|
|
|
|
static GPUVertexAttribs current_gpu_attribs;
|
|
|
|
static int CheckMaterialDM(int matnr, void *attribs)
|
|
|
|
{
|
|
|
|
// only draw the current material
|
|
|
|
if (matnr != current_blmat_nr)
|
|
|
|
return 0;
|
|
|
|
GPUVertexAttribs *gattribs = (GPUVertexAttribs *)attribs;
|
|
|
|
if (gattribs)
|
|
|
|
memcpy(gattribs, ¤t_gpu_attribs, sizeof(GPUVertexAttribs));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
static int CheckTexfaceDM(void *mcol, int index)
|
|
|
|
{
|
|
|
|
|
|
|
|
// index is the original face index, retrieve the polygon
|
|
|
|
RAS_Polygon* polygon = (index >= 0 && index < current_mesh->NumPolygons()) ?
|
|
|
|
current_mesh->GetPolygon(index) : NULL;
|
|
|
|
if (polygon && polygon->GetMaterial() == current_bucket) {
|
|
|
|
// must handle color.
|
|
|
|
if (current_wireframe)
|
|
|
|
return 2;
|
|
|
|
if (current_ms->m_bObjectColor) {
|
|
|
|
MT_Vector4& rgba = current_ms->m_RGBAcolor;
|
|
|
|
glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
|
|
|
|
// don't use mcol
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
if (!mcol) {
|
|
|
|
// we have to set the color from the material
|
|
|
|
unsigned char rgba[4];
|
|
|
|
current_polymat->GetMaterialRGBAColor(rgba);
|
|
|
|
glColor4ubv((const GLubyte *)rgba);
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
void RAS_OpenGLRasterizer::IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi)
|
2006-01-06 03:46:54 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
bool obcolor = ms.m_bObjectColor;
|
|
|
|
bool wireframe = m_drawingmode <= KX_WIREFRAME;
|
|
|
|
MT_Vector4& rgba = ms.m_RGBAcolor;
|
|
|
|
RAS_MeshSlot::iterator it;
|
|
|
|
|
2009-06-08 20:08:19 +00:00
|
|
|
if (ms.m_pDerivedMesh) {
|
|
|
|
// mesh data is in derived mesh,
|
|
|
|
current_bucket = ms.m_bucket;
|
|
|
|
current_polymat = current_bucket->GetPolyMaterial();
|
|
|
|
current_ms = &ms;
|
|
|
|
current_mesh = ms.m_mesh;
|
|
|
|
current_wireframe = wireframe;
|
2009-08-27 07:07:41 +00:00
|
|
|
MCol *mcol = (MCol*)ms.m_pDerivedMesh->getTessFaceDataArray(ms.m_pDerivedMesh, CD_MCOL);
|
2009-06-08 20:08:19 +00:00
|
|
|
if (current_polymat->GetFlag() & RAS_BLENDERGLSL) {
|
|
|
|
// GetMaterialIndex return the original mface material index,
|
|
|
|
// increment by 1 to match what derived mesh is doing
|
|
|
|
current_blmat_nr = current_polymat->GetMaterialIndex()+1;
|
|
|
|
// For GLSL we need to retrieve the GPU material attribute
|
|
|
|
Material* blmat = current_polymat->GetBlenderMaterial();
|
|
|
|
Scene* blscene = current_polymat->GetBlenderScene();
|
|
|
|
if (!wireframe && blscene && blmat)
|
|
|
|
GPU_material_vertex_attributes(GPU_material_from_blender(blscene, blmat), ¤t_gpu_attribs);
|
|
|
|
else
|
|
|
|
memset(¤t_gpu_attribs, 0, sizeof(current_gpu_attribs));
|
|
|
|
// DM draw can mess up blending mode, restore at the end
|
|
|
|
int current_blend_mode = GPU_get_material_blend_mode();
|
|
|
|
ms.m_pDerivedMesh->drawFacesGLSL(ms.m_pDerivedMesh, CheckMaterialDM);
|
|
|
|
GPU_set_material_blend_mode(current_blend_mode);
|
|
|
|
} else {
|
|
|
|
ms.m_pDerivedMesh->drawMappedFacesTex(ms.m_pDerivedMesh, CheckTexfaceDM, mcol);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
// iterate over display arrays, each containing an index + vertex array
|
|
|
|
for(ms.begin(it); !ms.end(it); ms.next(it)) {
|
|
|
|
RAS_TexVert *vertex;
|
|
|
|
size_t i, j, numvert;
|
|
|
|
|
|
|
|
numvert = it.array->m_type;
|
2008-04-16 17:40:59 +00:00
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
if(it.array->m_type == RAS_DisplayArray::LINE) {
|
|
|
|
// line drawing
|
|
|
|
glBegin(GL_LINES);
|
2008-04-16 17:40:59 +00:00
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
for(i=0; i<it.totindex; i+=2)
|
2006-01-06 03:46:54 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
vertex = &it.vertex[it.index[i]];
|
|
|
|
glVertex3fv(vertex->getXYZ());
|
|
|
|
|
|
|
|
vertex = &it.vertex[it.index[i+1]];
|
|
|
|
glVertex3fv(vertex->getXYZ());
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
glEnd();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// triangle and quad drawing
|
|
|
|
if(it.array->m_type == RAS_DisplayArray::TRIANGLE)
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
|
|
else
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
glBegin(GL_QUADS);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
for(i=0; i<it.totindex; i+=numvert)
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
if(obcolor)
|
|
|
|
glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
|
|
|
|
|
|
|
|
for(j=0; j<numvert; j++) {
|
|
|
|
vertex = &it.vertex[it.index[i+j]];
|
|
|
|
|
|
|
|
if(!wireframe) {
|
|
|
|
if(!obcolor)
|
|
|
|
glColor4ubv((const GLubyte *)(vertex->getRGBA()));
|
|
|
|
|
|
|
|
glNormal3fv(vertex->getNormal());
|
|
|
|
|
|
|
|
if(multi)
|
|
|
|
TexCoord(*vertex);
|
|
|
|
else
|
|
|
|
glTexCoord2fv(vertex->getUV1());
|
2006-01-06 03:46:54 +00:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
glVertex3fv(vertex->getXYZ());
|
2008-04-16 17:40:59 +00:00
|
|
|
}
|
Merge of apricot branch game engine changes into trunk, excluding GLSL.
GLEW
====
Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.
* According to the GLEW website it works on Windows, Linux, Mac OS X,
FreeBSD, Irix, and Solaris. There might still be platform specific
issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
regardless of the glext.h on the platform where compilation happens.
Game Engine
===========
Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.
The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.
For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.
* The game engine now also uses GLEW for extensions, replacing the
custom opengl extensions code that was there. Removes a lot of
#ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
work around a specific bug and only disabled multitexturing anyway.
It might also have caused a slowdown since it was retrieving the
environment variable for every vertex in immediate mode (bug #13680).
* Refactored the code to allow drawing skinned meshes with vertex
arrays too, removing some specific immediate mode drawing functions
for this that only did extra normal calculation. Now it always splits
vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
attributes for vertex arrays. These were not being enabled/disabled
correct according to the opengl spec, leading to crashes. Also tangent
attributes used an immediate mode call for vertex arrays, which can't
work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
deform weights, now uses same trick as regular meshes.
2008-06-17 10:27:34 +00:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
|
|
|
|
glEnd();
|
|
|
|
}
|
|
|
|
}
|
2006-01-06 03:46:54 +00:00
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetProjectionMatrix(MT_CmMatrix4x4 &mat)
|
|
|
|
{
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
double* matrix = &mat(0,0);
|
|
|
|
glLoadMatrixd(matrix);
|
|
|
|
|
2009-02-06 19:21:24 +00:00
|
|
|
m_camortho= (mat(3, 3) != 0.0f);
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
2004-05-16 12:55:21 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetProjectionMatrix(const MT_Matrix4x4 & mat)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
double matrix[16];
|
|
|
|
/* Get into argument. Looks a bit dodgy, but it's ok. */
|
|
|
|
mat.getValue(matrix);
|
|
|
|
/* Internally, MT_Matrix4x4 uses doubles (MT_Scalar). */
|
|
|
|
glLoadMatrixd(matrix);
|
2009-02-06 19:21:24 +00:00
|
|
|
|
|
|
|
m_camortho= (mat[3][3] != 0.0f);
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MT_Matrix4x4 RAS_OpenGLRasterizer::GetFrustumMatrix(
|
|
|
|
float left,
|
|
|
|
float right,
|
|
|
|
float bottom,
|
|
|
|
float top,
|
|
|
|
float frustnear,
|
2004-04-11 02:50:02 +00:00
|
|
|
float frustfar,
|
2008-05-24 08:34:04 +00:00
|
|
|
float focallength,
|
2008-11-26 17:38:54 +00:00
|
|
|
bool
|
2002-10-12 11:37:38 +00:00
|
|
|
){
|
|
|
|
MT_Matrix4x4 result;
|
|
|
|
double mat[16];
|
|
|
|
|
|
|
|
// correction for stereo
|
2009-04-20 15:06:46 +00:00
|
|
|
if(Stereo())
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
|
|
|
float near_div_focallength;
|
|
|
|
// next 2 params should be specified on command line and in Blender publisher
|
2004-10-24 23:50:44 +00:00
|
|
|
if (!m_setfocallength)
|
2008-05-24 08:34:04 +00:00
|
|
|
m_focallength = (focallength == 0.f) ? 1.5 * right // derived from example
|
|
|
|
: focallength;
|
2004-10-24 23:50:44 +00:00
|
|
|
if (!m_seteyesep)
|
2008-05-24 08:34:04 +00:00
|
|
|
m_eyeseparation = m_focallength/30; // reasonable value...
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
near_div_focallength = frustnear / m_focallength;
|
|
|
|
switch(m_curreye)
|
|
|
|
{
|
|
|
|
case RAS_STEREO_LEFTEYE:
|
|
|
|
left += 0.5 * m_eyeseparation * near_div_focallength;
|
|
|
|
right += 0.5 * m_eyeseparation * near_div_focallength;
|
|
|
|
break;
|
|
|
|
case RAS_STEREO_RIGHTEYE:
|
|
|
|
left -= 0.5 * m_eyeseparation * near_div_focallength;
|
|
|
|
right -= 0.5 * m_eyeseparation * near_div_focallength;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// leave bottom, top, bottom and top untouched
|
|
|
|
}
|
2004-04-11 02:50:02 +00:00
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
glLoadIdentity();
|
|
|
|
glFrustum(left, right, bottom, top, frustnear, frustfar);
|
2004-04-11 02:50:02 +00:00
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
glGetDoublev(GL_PROJECTION_MATRIX, mat);
|
|
|
|
result.setValue(mat);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2009-06-08 20:08:19 +00:00
|
|
|
MT_Matrix4x4 RAS_OpenGLRasterizer::GetOrthoMatrix(
|
|
|
|
float left,
|
|
|
|
float right,
|
|
|
|
float bottom,
|
|
|
|
float top,
|
|
|
|
float frustnear,
|
|
|
|
float frustfar
|
|
|
|
){
|
|
|
|
MT_Matrix4x4 result;
|
|
|
|
double mat[16];
|
|
|
|
|
|
|
|
// stereo is meaning less for orthographic, disable it
|
|
|
|
glMatrixMode(GL_PROJECTION);
|
|
|
|
glLoadIdentity();
|
|
|
|
glOrtho(left, right, bottom, top, frustnear, frustfar);
|
|
|
|
|
|
|
|
glGetDoublev(GL_PROJECTION_MATRIX, mat);
|
|
|
|
result.setValue(mat);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
// next arguments probably contain redundant info, for later...
|
2009-06-08 20:08:19 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetViewMatrix(const MT_Matrix4x4 &mat,
|
|
|
|
const MT_Matrix3x3 & camOrientMat3x3,
|
|
|
|
const MT_Point3 & pos,
|
|
|
|
bool perspective)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
m_viewmatrix = mat;
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
// correction for stereo
|
2009-06-08 20:08:19 +00:00
|
|
|
if(Stereo() && perspective)
|
2002-10-12 11:37:38 +00:00
|
|
|
{
|
|
|
|
MT_Vector3 unitViewDir(0.0, -1.0, 0.0); // minus y direction, Blender convention
|
|
|
|
MT_Vector3 unitViewupVec(0.0, 0.0, 1.0);
|
|
|
|
MT_Vector3 viewDir, viewupVec;
|
|
|
|
MT_Vector3 eyeline;
|
|
|
|
|
|
|
|
// actual viewDir
|
|
|
|
viewDir = camOrientMat3x3 * unitViewDir; // this is the moto convention, vector on right hand side
|
|
|
|
// actual viewup vec
|
|
|
|
viewupVec = camOrientMat3x3 * unitViewupVec;
|
|
|
|
|
|
|
|
// vector between eyes
|
|
|
|
eyeline = viewDir.cross(viewupVec);
|
|
|
|
|
|
|
|
switch(m_curreye)
|
|
|
|
{
|
|
|
|
case RAS_STEREO_LEFTEYE:
|
|
|
|
{
|
|
|
|
// translate to left by half the eye distance
|
|
|
|
MT_Transform transform;
|
|
|
|
transform.setIdentity();
|
|
|
|
transform.translate(-(eyeline * m_eyeseparation / 2.0));
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
m_viewmatrix *= transform;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RAS_STEREO_RIGHTEYE:
|
|
|
|
{
|
|
|
|
// translate to right by half the eye distance
|
|
|
|
MT_Transform transform;
|
|
|
|
transform.setIdentity();
|
|
|
|
transform.translate(eyeline * m_eyeseparation / 2.0);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
m_viewmatrix *= transform;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
m_viewinvmatrix = m_viewmatrix;
|
|
|
|
m_viewinvmatrix.invert();
|
|
|
|
|
|
|
|
// note: getValue gives back column major as needed by OpenGL
|
|
|
|
MT_Scalar glviewmat[16];
|
|
|
|
m_viewmatrix.getValue(glviewmat);
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
glLoadMatrixd(glviewmat);
|
2009-06-08 20:08:19 +00:00
|
|
|
m_campos = pos;
|
2002-10-12 11:37:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const MT_Point3& RAS_OpenGLRasterizer::GetCameraPosition()
|
|
|
|
{
|
|
|
|
return m_campos;
|
|
|
|
}
|
|
|
|
|
2009-02-06 19:21:24 +00:00
|
|
|
bool RAS_OpenGLRasterizer::GetCameraOrtho()
|
|
|
|
{
|
|
|
|
return m_camortho;
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetCullFace(bool enable)
|
|
|
|
{
|
|
|
|
if (enable)
|
|
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
else
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
}
|
|
|
|
|
2004-03-22 22:02:18 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetLines(bool enable)
|
|
|
|
{
|
|
|
|
if (enable)
|
|
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
|
|
|
else
|
|
|
|
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
|
|
|
}
|
2002-10-12 11:37:38 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetSpecularity(float specX,
|
|
|
|
float specY,
|
|
|
|
float specZ,
|
|
|
|
float specval)
|
|
|
|
{
|
|
|
|
GLfloat mat_specular[] = {specX, specY, specZ, specval};
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetShinyness(float shiny)
|
|
|
|
{
|
|
|
|
GLfloat mat_shininess[] = { shiny };
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetDiffuse(float difX,float difY,float difZ,float diffuse)
|
|
|
|
{
|
|
|
|
GLfloat mat_diffuse [] = {difX, difY,difZ, diffuse};
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
|
|
|
|
}
|
|
|
|
|
2006-01-06 03:46:54 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetEmissive(float eX, float eY, float eZ, float e)
|
|
|
|
{
|
|
|
|
GLfloat mat_emit [] = {eX,eY,eZ,e};
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, mat_emit);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-10-12 11:37:38 +00:00
|
|
|
double RAS_OpenGLRasterizer::GetTime()
|
|
|
|
{
|
|
|
|
return m_time;
|
|
|
|
}
|
|
|
|
|
2005-01-16 06:02:06 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetPolygonOffset(float mult, float add)
|
|
|
|
{
|
|
|
|
glPolygonOffset(mult, add);
|
|
|
|
GLint mode = GL_POLYGON_OFFSET_FILL;
|
|
|
|
if (m_drawingmode < KX_SHADED)
|
|
|
|
mode = GL_POLYGON_OFFSET_LINE;
|
|
|
|
if (mult != 0.0f || add != 0.0f)
|
|
|
|
glEnable(mode);
|
|
|
|
else
|
|
|
|
glDisable(mode);
|
|
|
|
}
|
2007-09-29 18:51:01 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::EnableMotionBlur(float motionblurvalue)
|
|
|
|
{
|
2008-09-15 00:57:11 +00:00
|
|
|
/* don't just set m_motionblur to 1, but check if it is 0 so
|
|
|
|
* we don't reset a motion blur that is already enabled */
|
|
|
|
if(m_motionblur == 0)
|
|
|
|
m_motionblur = 1;
|
2007-09-29 18:51:01 +00:00
|
|
|
m_motionblurvalue = motionblurvalue;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::DisableMotionBlur()
|
|
|
|
{
|
|
|
|
m_motionblur = 0;
|
|
|
|
m_motionblurvalue = -1.0;
|
|
|
|
}
|
2008-07-29 15:48:31 +00:00
|
|
|
|
|
|
|
void RAS_OpenGLRasterizer::SetBlendingMode(int blendmode)
|
|
|
|
{
|
2009-06-08 20:08:19 +00:00
|
|
|
GPU_set_material_blend_mode(blendmode);
|
|
|
|
/*
|
2008-07-29 15:48:31 +00:00
|
|
|
if(blendmode == m_last_blendmode)
|
|
|
|
return;
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
if(blendmode == GPU_BLEND_SOLID) {
|
2008-07-29 15:48:31 +00:00
|
|
|
glDisable(GL_BLEND);
|
|
|
|
glDisable(GL_ALPHA_TEST);
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
else if(blendmode == GPU_BLEND_ADD) {
|
2008-07-29 15:48:31 +00:00
|
|
|
glBlendFunc(GL_ONE, GL_ONE);
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glDisable(GL_ALPHA_TEST);
|
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
else if(blendmode == GPU_BLEND_ALPHA) {
|
2008-07-29 15:48:31 +00:00
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glEnable(GL_ALPHA_TEST);
|
|
|
|
glAlphaFunc(GL_GREATER, 0.0f);
|
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
else if(blendmode == GPU_BLEND_CLIP) {
|
2008-07-29 15:48:31 +00:00
|
|
|
glDisable(GL_BLEND);
|
|
|
|
glEnable(GL_ALPHA_TEST);
|
|
|
|
glAlphaFunc(GL_GREATER, 0.5f);
|
|
|
|
}
|
|
|
|
|
|
|
|
m_last_blendmode = blendmode;
|
2009-06-08 20:08:19 +00:00
|
|
|
*/
|
2008-07-29 15:48:31 +00:00
|
|
|
}
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 20:51:28 +00:00
|
|
|
void RAS_OpenGLRasterizer::SetFrontFace(bool ccw)
|
|
|
|
{
|
|
|
|
if(m_last_frontface == ccw)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if(ccw)
|
|
|
|
glFrontFace(GL_CCW);
|
|
|
|
else
|
|
|
|
glFrontFace(GL_CW);
|
|
|
|
|
|
|
|
m_last_frontface = ccw;
|
|
|
|
}
|
|
|
|
|