Initial revision

source/gameengine/Rasterizer/RAS_OpenGLRasterizer/Makefile

@@ -0,0 +1,47 @@
+#
+# $Id$
+#
+# ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version. The Blender
+# Foundation also sells licenses for use in proprietary software under
+# the Blender License.  See http://www.blender.org/BL/ for information
+# about this.
+#
+# 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.
+#
+# ***** END GPL/BL DUAL LICENSE BLOCK *****
+#
+# Bounce make to subdirectories.
+#
+
+LIBNAME = OpenGLrasterizer
+DIR = $(OCGDIR)/gameengine/$(LIBNAME)
+
+include nan_compile.mk
+
+CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
+
+CPPFLAGS += -I$(OPENGL_HEADERS)
+CPPFLAGS += -I$(NAN_STRING)/include    
+CPPFLAGS += -I$(NAN_MOTO)/include
+CPPFLAGS += -I../../../kernel/gen_system
+CPPFLAGS += -I..
+

source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp

@@ -0,0 +1,61 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+#include "RAS_CheckVertexArrays.h"
+
+#ifdef WIN32
+#include <windows.h>
+#endif // WIN32
+#include "GL/gl.h"
+
+#include "STR_String.h"
+
+
+bool	RAS_SystemSupportsVertexArrays() {
+
+	bool result = false;
+
+	char* ext = (char*) glGetString(GL_EXTENSIONS);
+	STR_String extensions;
+		
+	if (ext)
+		extensions = STR_String(ext);
+
+#ifdef WIN32
+	if (extensions.Find("GL_EXT_compiled_vertex_array") >= 0)
+	{
+		result=true;
+	}
+#endif //WIN32
+
+	return result;
+
+}

source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h

@@ -0,0 +1,37 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+#ifndef __RAS_CHECKVERTEXARRAYS
+#define __RAS_CHECKVERTEXARRAYS
+
+bool RAS_SystemSupportsVertexArrays();
+
+#endif //__RAS_CHECKVERTEXARRAYS

source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h

@@ -0,0 +1,226 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+#ifndef __RAS_OPENGLRASTERIZER
+#define __RAS_OPENGLRASTERIZER
+
+#ifdef WIN32
+#pragma warning (disable:4786)
+#endif
+
+#include "MT_CmMatrix4x4.h"
+#include <vector>
+using namespace std;
+
+
+#include "RAS_IRasterizer.h"
+#include "RAS_MaterialBucket.h"
+#include "RAS_ICanvas.h"
+
+/**
+ * 3D rendering device context.
+ */
+class RAS_OpenGLRasterizer : public RAS_IRasterizer
+{
+
+	RAS_ICanvas*	m_2DCanvas;
+	
+	// fogging vars
+	bool			m_fogenabled;
+	float			m_fogstart;
+	float			m_fogdist;
+	float			m_fogr;
+	float			m_fogg;
+	float			m_fogb;
+	
+	float			m_redback;
+	float			m_greenback;
+	float			m_blueback;
+	float			m_alphaback;
+
+	bool			m_bEXT_compiled_vertex_array;
+
+	double			m_time;
+	MT_CmMatrix4x4	m_viewmatrix;
+	MT_Point3		m_campos;
+
+	int				m_stereomode;
+	int				m_curreye;
+	float			m_eyeseparation;
+	float			m_focallength;
+	int				m_noOfScanlines;
+
+protected:
+	int				m_drawingmode;
+	/** Stores the caching information for the last material activated. */
+	RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;
+
+public:
+	double GetTime();
+	RAS_OpenGLRasterizer(RAS_ICanvas* canv);
+	virtual ~RAS_OpenGLRasterizer();
+
+
+
+	enum
+	{
+			KX_BOUNDINGBOX = 1,
+			KX_WIREFRAME,
+			KX_SOLID,
+			KX_SHADED,
+			KX_TEXTURED 
+	};
+
+	enum
+	{
+			KX_DEPTHMASK_ENABLED =1,
+			KX_DEPTHMASK_DISABLED,
+	};
+	virtual void	SetDepthMask(int depthmask);
+
+	virtual void	SetMaterial(const RAS_IPolyMaterial& mat);
+	virtual bool	Init();
+	virtual void	Exit();
+	virtual bool	BeginFrame(int drawingmode, double time);
+	virtual void	ClearDepthBuffer();
+	virtual void	ClearCachingInfo(void);
+	virtual void	EndFrame();
+	virtual void	SetRenderArea();
+
+	virtual void	SetStereoMode(const int stereomode);
+	virtual bool	Stereo();
+	virtual void	SetEye(const int eye);
+	virtual void	SetEyeSeparation(const float eyeseparation);
+	virtual void	SetFocalLength(const float focallength);
+
+	virtual void	SwapBuffers();
+	virtual void	IndexPrimitives(
+						const vecVertexArray& vertexarrays,
+						const vecIndexArrays & indexarrays,
+						int mode,
+						class RAS_IPolyMaterial* polymat,
+						class RAS_IRenderTools* rendertools,
+						bool useObjectColor,
+						const MT_Vector4& rgbacolor
+					);
+
+	virtual void	IndexPrimitives_Ex(
+						const vecVertexArray& vertexarrays,
+						const vecIndexArrays & indexarrays,
+						int mode,
+						class RAS_IPolyMaterial* polymat,
+						class RAS_IRenderTools* rendertools,
+						bool useObjectColor,
+						const MT_Vector4& rgbacolor
+					);
+
+	virtual void	IndexPrimitives_3DText(
+						const vecVertexArray& vertexarrays,
+						const vecIndexArrays & indexarrays,
+						int mode,
+						class RAS_IPolyMaterial* polymat,
+						class RAS_IRenderTools* rendertools,
+						bool useObjectColor,
+						const MT_Vector4& rgbacolor
+					);
+
+	virtual void	SetProjectionMatrix(MT_CmMatrix4x4 & mat);
+	virtual void	SetProjectionMatrix(MT_Matrix4x4 & mat);
+	virtual void	SetViewMatrix(
+						const MT_Matrix4x4 & mat,
+						const MT_Vector3& campos,
+						const MT_Point3 &camLoc,
+						const MT_Quaternion &camOrientQuat
+					);
+
+	virtual const	MT_Point3& GetCameraPosition();
+	virtual void	LoadViewMatrix();
+	
+	virtual void	SetFog(
+						float start,
+						float dist,
+						float r,
+						float g,
+						float b
+					);
+
+	virtual void	SetFogColor(
+						float r,
+						float g,
+						float b
+					);
+
+	virtual void	SetFogStart(float fogstart);
+	virtual void	SetFogEnd(float fogend);
+
+	void			DisableFog();
+	virtual void	DisplayFog();
+
+	virtual void	SetBackColor(
+						float red,
+						float green,
+						float blue,
+						float alpha
+					);
+	
+	virtual void	SetDrawingMode(int drawingmode);
+	virtual int		GetDrawingMode();
+
+	virtual void	EnableTextures(bool enable);
+	virtual void	SetCullFace(bool enable);
+
+	virtual MT_Matrix4x4 GetFrustumMatrix(
+							float left,
+							float right,
+							float bottom,
+							float top,
+							float frustnear,
+							float frustfar
+						);
+
+	virtual void	SetSpecularity(
+						float specX,
+						float specY,
+						float specZ,
+						float specval
+					);
+
+	virtual void	SetShinyness(float shiny);
+	virtual void	SetDiffuse(
+						float difX,
+						float difY,
+						float difZ,
+						float diffuse
+					);
+
+};
+
+#endif //__RAS_OPENGLRASTERIZER

source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.cpp

@@ -0,0 +1,215 @@
+#ifdef WIN32
+
+
+#include "RAS_VAOpenGLRasterizer.h"
+
+
+#include <windows.h>
+#include "GL/gl.h"
+
+typedef void (APIENTRY *GLLOCKARRAYSEXTPTR)(GLint first,GLsizei count);
+typedef void (APIENTRY *GLUNLOCKARRAYSEXTPTR)(void);
+void APIENTRY RAS_lockfunc(GLint first,GLsizei count) {};
+void APIENTRY RAS_unlockfunc() {};
+GLLOCKARRAYSEXTPTR glLockArraysEXT=RAS_lockfunc;
+GLUNLOCKARRAYSEXTPTR glUnlockArraysEXT=RAS_unlockfunc;
+
+
+
+
+#include "STR_String.h"
+#include "RAS_TexVert.h"
+#include "MT_CmMatrix4x4.h"
+#include "RAS_IRenderTools.h" // rendering text
+
+	
+RAS_VAOpenGLRasterizer::RAS_VAOpenGLRasterizer(RAS_ICanvas* canvas)
+:RAS_OpenGLRasterizer(canvas)
+{
+	int i = 0;
+}
+
+
+
+RAS_VAOpenGLRasterizer::~RAS_VAOpenGLRasterizer()
+{
+}
+
+
+
+bool RAS_VAOpenGLRasterizer::Init()
+{
+	
+	bool result = RAS_OpenGLRasterizer::Init();
+	
+	if (result)
+	{
+		// if possible, add extensions to other platforms too, if this
+		// rasterizer becomes messy just derive one for each platform 
+		// (ie. KX_Win32Rasterizer, KX_LinuxRasterizer etc.)
+		
+		glUnlockArraysEXT = reinterpret_cast<GLUNLOCKARRAYSEXTPTR>(wglGetProcAddress("glUnlockArraysEXT"));
+		if (!glUnlockArraysEXT)
+			result = false;
+		
+		glLockArraysEXT = reinterpret_cast<GLLOCKARRAYSEXTPTR>(wglGetProcAddress("glLockArraysEXT"));
+		if (!glLockArraysEXT)
+			result=false;
+		
+		glEnableClientState(GL_VERTEX_ARRAY);
+		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+		glDisableClientState(GL_NORMAL_ARRAY);
+		glDisableClientState(GL_COLOR_ARRAY);
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	}
+
+	return result;
+}
+
+
+
+void RAS_VAOpenGLRasterizer::SetDrawingMode(int drawingmode)
+{
+	m_drawingmode = drawingmode;
+
+		switch (m_drawingmode)
+	{
+	case KX_BOUNDINGBOX:
+		{
+		}
+	case KX_WIREFRAME:
+		{
+			glDisable (GL_CULL_FACE);
+			break;
+		}
+	case KX_TEXTURED:
+		{
+		}
+	case KX_SHADED:
+		{
+			glEnableClientState(GL_COLOR_ARRAY);
+		}
+	case KX_SOLID:
+		{
+			break;
+		}
+	default:
+		{
+		}
+	}
+}
+
+
+
+void RAS_VAOpenGLRasterizer::Exit()
+{
+	glDisableClientState(GL_VERTEX_ARRAY);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
+	glDisableClientState(GL_NORMAL_ARRAY);
+	glDisable(GL_COLOR_MATERIAL);
+
+	RAS_OpenGLRasterizer::Exit();
+}
+
+
+
+void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays,
+							const vecIndexArrays & indexarrays,
+							int mode,
+							class RAS_IPolyMaterial* polymat,
+							class RAS_IRenderTools* rendertools,
+							bool useObjectColor,
+							const MT_Vector4& rgbacolor)
+{
+	unsigned char* mypointer=NULL;
+	static const GLsizei vtxstride = sizeof(RAS_TexVert);
+	GLenum drawmode;
+	switch (mode)
+	{
+	case 0:
+		{
+		drawmode = GL_TRIANGLES;
+		break;
+		}
+	case 2:
+		{
+		drawmode = GL_QUADS;
+		break;
+		}
+	case 1:	//lines
+		{
+		}
+	default:
+		{
+		drawmode = GL_LINES;
+		break;
+		}
+	}
+	const RAS_TexVert* vertexarray;
+	int numindices,vt;
+	if (drawmode != GL_LINES)
+	{
+		if (useObjectColor)
+		{
+			glDisableClientState(GL_COLOR_ARRAY);
+			glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]);
+		} else
+		{
+			glColor4d(0,0,0,1.0);
+			glEnableClientState(GL_COLOR_ARRAY);
+		}
+	}
+	else
+	{
+		glColor3d(0,0,0);
+	}
+	// use glDrawElements to draw each vertexarray
+	for (vt=0;vt<vertexarrays.size();vt++)
+	{
+		vertexarray = &((*vertexarrays[vt]) [0]);
+		const KX_IndexArray & indexarray = (*indexarrays[vt]);
+		numindices = indexarray.size();
+		int numverts = vertexarrays[vt]->size();
+
+		if (!numindices)
+			break;
+		
+		mypointer = (unsigned char*)(vertexarray);
+		glVertexPointer(3,GL_FLOAT,vtxstride,mypointer);
+		mypointer+= 3*sizeof(float);
+		glTexCoordPointer(2,GL_FLOAT,vtxstride,mypointer);
+		mypointer+= 2*sizeof(float);
+		glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,mypointer);
+		mypointer += sizeof(int);
+		glNormalPointer(GL_SHORT,vtxstride,mypointer);
+		glLockArraysEXT(0,numverts);
+		// here the actual drawing takes places
+		glDrawElements(drawmode,numindices,GL_UNSIGNED_INT,&(indexarray[0]));
+		glUnlockArraysEXT();
+	}
+}
+
+
+void RAS_VAOpenGLRasterizer::EnableTextures(bool enable)
+{
+	if (enable)
+		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	else
+		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+}
+
+bool RAS_VAOpenGLRasterizer::Stereo()
+{
+/*
+	if(m_stereomode == RAS_STEREO_NOSTEREO)
+		return false;
+	else
+		return true;
+*/
+	return false;
+}
+
+
+#endif //WIN32

source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_VAOpenGLRasterizer.h

@@ -0,0 +1,62 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+#ifndef __KX_VERTEXARRAYOPENGLRASTERIZER
+#define __KX_VERTEXARRAYOPENGLRASTERIZER
+
+#include "RAS_OpenGLRasterizer.h"
+
+class RAS_VAOpenGLRasterizer : public RAS_OpenGLRasterizer
+{
+public:
+	RAS_VAOpenGLRasterizer(RAS_ICanvas* canvas);
+	virtual ~RAS_VAOpenGLRasterizer();
+
+	virtual bool	Init();
+	virtual void	Exit();
+
+	virtual bool	Stereo();
+	virtual void	SetDrawingMode(int drawingmode);
+
+	virtual void	IndexPrimitives( const vecVertexArray& vertexarrays,
+							const vecIndexArrays & indexarrays,
+							int mode,
+							class RAS_IPolyMaterial* polymat,
+							class RAS_IRenderTools* rendertools,
+							bool useObjectColor,
+							const MT_Vector4& rgbacolor);
+
+
+	virtual void	EnableTextures(bool enable);
+
+};
+
+#endif //__KX_VERTEXARRAYOPENGLRASTERIZER