vbo_patch.diff
Public
Actions

Authored By

	Sergey Svistunov (svistunov)
	Nov 13 2013, 4:05 PM

Size

27 KB

Subscribers

None

vbo_patch.diff
View Options

	Index: release/scripts/startup/bl_ui/properties_game.py
	===================================================================
	--- release/scripts/startup/bl_ui/properties_game.py (revision 45937)
	+++ release/scripts/startup/bl_ui/properties_game.py (working copy)
	@@ -397,6 +397,8 @@
	row.prop(gs, "use_display_lists")

	row = layout.row()
	+ row.prop(gs, "raster_storage")
	+ row = layout.row()
	row.label("Exit Key")
	row.prop(gs, "exit_key", text="", event=True)

	Index: source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
	===================================================================
	--- source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp (revision 45937)
	+++ source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp (working copy)
	@@ -57,7 +57,6 @@

	#include "RAS_GLExtensionManager.h"
	#include "RAS_OpenGLRasterizer.h"
	-#include "RAS_VAOpenGLRasterizer.h"
	#include "RAS_ListRasterizer.h"

	#include "NG_LoopBackNetworkDeviceInterface.h"
	@@ -205,16 +204,12 @@
	RAS_IRenderTools* rendertools = new KX_BlenderRenderTools();
	RAS_IRasterizer* rasterizer = NULL;

	- if (displaylists) {
	- if (GLEW_VERSION_1_1 && !novertexarrays)
	- rasterizer = new RAS_ListRasterizer(canvas, true, true);
	- else
	- rasterizer = new RAS_ListRasterizer(canvas);
	- }
	- else if (GLEW_VERSION_1_1 && !novertexarrays)
	- rasterizer = new RAS_VAOpenGLRasterizer(canvas, false);
	+ //Don't use displaylists with VBOs
	+ //If auto starts using VBOs, make sure to check for that here
	+ if (displaylists && startscene->gm.raster_storage != RAS_STORE_VBO)
	+ rasterizer = new RAS_ListRasterizer(canvas, true, startscene->gm.raster_storage);
	else
	- rasterizer = new RAS_OpenGLRasterizer(canvas);
	+ rasterizer = new RAS_OpenGLRasterizer(canvas, startscene->gm.raster_storage);

	// create the inputdevices
	KX_BlenderKeyboardDevice* keyboarddevice = new KX_BlenderKeyboardDevice();
	Index: source/gameengine/GamePlayer/ghost/GPG_Application.cpp
	===================================================================
	--- source/gameengine/GamePlayer/ghost/GPG_Application.cpp (revision 45937)
	+++ source/gameengine/GamePlayer/ghost/GPG_Application.cpp (working copy)
	@@ -76,7 +76,6 @@
	#include "SCA_IActuator.h"
	#include "RAS_MeshObject.h"
	#include "RAS_OpenGLRasterizer.h"
	-#include "RAS_VAOpenGLRasterizer.h"
	#include "RAS_ListRasterizer.h"
	#include "RAS_GLExtensionManager.h"
	#include "KX_PythonInit.h"
	@@ -579,16 +578,12 @@
	if (!m_rendertools)
	goto initFailed;

	- if (useLists) {
	- if (GLEW_VERSION_1_1)
	- m_rasterizer = new RAS_ListRasterizer(m_canvas, true);
	- else
	- m_rasterizer = new RAS_ListRasterizer(m_canvas);
	- }
	- else if (GLEW_VERSION_1_1)
	- m_rasterizer = new RAS_VAOpenGLRasterizer(m_canvas);
	+ //Don't use displaylists with VBOs
	+ //If auto starts using VBOs, make sure to check for that here
	+ if(useLists && gm->raster_storage != RAS_STORE_VBO)
	+ m_rasterizer = new RAS_ListRasterizer(m_canvas, false, gm->raster_storage);
	else
	- m_rasterizer = new RAS_OpenGLRasterizer(m_canvas);
	+ m_rasterizer = new RAS_OpenGLRasterizer(m_canvas, gm->raster_storage);

	/* Stereo parameters - Eye Separation from the UI - stereomode from the command-line/UI */
	m_rasterizer->SetStereoMode((RAS_IRasterizer::StereoMode) stereoMode);
	Index: source/gameengine/Ketsji/KX_MeshProxy.h
	===================================================================
	--- source/gameengine/Ketsji/KX_MeshProxy.h (revision 45937)
	+++ source/gameengine/Ketsji/KX_MeshProxy.h (working copy)
	@@ -71,6 +71,7 @@
	KX_PYMETHOD(KX_MeshProxy,GetVertexArrayLength);
	KX_PYMETHOD(KX_MeshProxy,GetVertex);
	KX_PYMETHOD(KX_MeshProxy,GetPolygon);
	+ KX_PYMETHOD(KX_MeshProxy,GetVBOId);

	static PyObject* pyattr_get_materials(void* self_v, const KX_PYATTRIBUTE_DEF *attrdef);
	static PyObject * pyattr_get_numMaterials(void * self, const KX_PYATTRIBUTE_DEF * attrdef);
	Index: source/gameengine/Ketsji/KX_MeshProxy.cpp
	===================================================================
	--- source/gameengine/Ketsji/KX_MeshProxy.cpp (revision 45937)
	+++ source/gameengine/Ketsji/KX_MeshProxy.cpp (working copy)
	@@ -74,6 +74,7 @@
	{"getTextureName", (PyCFunction)KX_MeshProxy::sPyGetTextureName,METH_VARARGS},
	{"getVertexArrayLength", (PyCFunction)KX_MeshProxy::sPyGetVertexArrayLength,METH_VARARGS},
	{"getVertex", (PyCFunction)KX_MeshProxy::sPyGetVertex,METH_VARARGS},
	+{"getVBOId", (PyCFunction)KX_MeshProxy::sPyGetVBOId,METH_VARARGS},
	{"getPolygon", (PyCFunction)KX_MeshProxy::sPyGetPolygon,METH_VARARGS},
	//{"getIndexArrayLength", (PyCFunction)KX_MeshProxy::sPyGetIndexArrayLength,METH_VARARGS},
	{NULL,NULL} //Sentinel
	@@ -113,7 +114,6 @@
	void KX_MeshProxy::SetName(const char *name) { };
	CValue* KX_MeshProxy::GetReplica() { return NULL;}

	-
	// stuff for python integration

	PyObject* KX_MeshProxy::PyGetMaterialName(PyObject* args, PyObject* kwds)
	@@ -192,6 +192,17 @@
	return (new KX_VertexProxy(this, vertex))->NewProxy(true);
	}

	+PyObject * KX_MeshProxy::PyGetVBOId(PyObject* args, PyObject* kwds)
	+{
	+ int index = 0;
	+ char* name;
	+
	+ if (!PyArg_ParseTuple(args,"is:getVBOId",&index, &name))
	+ return NULL;
	+
	+ return PyLong_FromSsize_t(m_meshobj->GetVBOId(index, name));
	+}
	+
	PyObject* KX_MeshProxy::PyGetPolygon(PyObject* args, PyObject* kwds)
	{
	int polyindex= 1;
	@@ -259,6 +270,7 @@
	return PyLong_FromSsize_t(self->m_meshobj->NumPolygons());
	}

	+
	/* a close copy of ConvertPythonToGameObject but for meshes */
	bool ConvertPythonToMesh(PyObject * value, RAS_MeshObject *object, bool py_none_ok, const char error_prefix)
	{
	Index: source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.h
	===================================================================
	--- source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.h (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.h (working copy)
	@@ -7,7 +7,7 @@
	#define __RAS_LISTRASTERIZER_H__

	#include "RAS_MaterialBucket.h"
	-#include "RAS_VAOpenGLRasterizer.h"
	+#include "RAS_OpenGLRasterizer.h"
	#include <vector>
	#include <map>

	@@ -49,7 +49,7 @@
	typedef std::vector<RAS_ListSlot*> RAS_ListSlots; // indexed by material slot number
	typedef std::map<DerivedMesh, RAS_ListSlots> RAS_DerivedMeshLists;

	-class RAS_ListRasterizer : public RAS_VAOpenGLRasterizer
	+class RAS_ListRasterizer : public RAS_OpenGLRasterizer
	{
	bool mUseVertexArrays;
	bool mATI;
	@@ -61,7 +61,7 @@

	public:
	void RemoveListSlot(RAS_ListSlot* list);
	- RAS_ListRasterizer(RAS_ICanvas* canvas, bool useVertexArrays=false, bool lock=false);
	+ RAS_ListRasterizer(RAS_ICanvas* canvas, bool lock=false, int storage=RAS_AUTO_STORAGE);
	virtual ~RAS_ListRasterizer();

	virtual void IndexPrimitives(class RAS_MeshSlot& ms);
	Index: source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
	===================================================================
	--- source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp (working copy)
	@@ -43,6 +43,10 @@
	#include "MT_CmMatrix4x4.h"
	#include "RAS_IRenderTools.h" // rendering text

	+#include "RAS_StorageIM.h"
	+#include "RAS_StorageVA.h"
	+#include "RAS_StorageVBO.h"
	+
	#include "GPU_draw.h"
	#include "GPU_material.h"
	#include "GPU_extensions.h"
	@@ -71,7 +75,7 @@
	*/
	static GLuint hinterlace_mask[33];

	-RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas)
	+RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas, int storage)
	:RAS_IRasterizer(canvas),
	m_2DCanvas(canvas),
	m_fogenabled(false),
	@@ -90,7 +94,8 @@
	m_attrib_num(0),
	//m_last_alphablend(GPU_BLEND_SOLID),
	m_last_frontface(true),
	- m_materialCachingInfo(0)
	+ m_materialCachingInfo(0),
	+ m_storage_type(storage)
	{
	m_viewmatrix.setIdentity();
	m_viewinvmatrix.setIdentity();
	@@ -104,6 +109,24 @@
	hinterlace_mask[32] = 0;

	m_prevafvalue = GPU_get_anisotropic();
	+
	+ if (m_storage_type == RAS_VBO /\|\| m_storage_type == RAS_AUTO_STORAGE && GLEW_ARB_vertex_buffer_object/)
	+ {
	+ m_storage = new RAS_StorageVBO(&m_texco_num, m_texco, &m_attrib_num, m_attrib);
	+ m_failsafe_storage = new RAS_StorageIM(&m_texco_num, m_texco, &m_attrib_num, m_attrib);
	+ m_storage_type = RAS_VBO;
	+ }
	+ else if (m_storage_type == RAS_VA \|\| m_storage_type == RAS_AUTO_STORAGE && GLEW_VERSION_1_1)
	+ {
	+ m_storage = new RAS_StorageVA(&m_texco_num, m_texco, &m_attrib_num, m_attrib);
	+ m_failsafe_storage = new RAS_StorageIM(&m_texco_num, m_texco, &m_attrib_num, m_attrib);
	+ m_storage_type = RAS_VA;
	+ }
	+ else
	+ {
	+ m_storage = m_failsafe_storage = new RAS_StorageIM(&m_texco_num, m_texco, &m_attrib_num, m_attrib);
	+ m_storage_type = RAS_IMMEDIATE;
	+ }
	}


	@@ -112,10 +135,12 @@
	{
	// Restore the previous AF value
	GPU_set_anisotropic(m_prevafvalue);
	+ delete m_storage;
	}

	bool RAS_OpenGLRasterizer::Init()
	{
	+ bool storage_init;
	GPU_state_init();


	@@ -143,7 +168,9 @@

	glShadeModel(GL_SMOOTH);

	- return true;
	+ storage_init = m_storage->Init();
	+
	+ return true && storage_init;
	}


	@@ -264,6 +291,8 @@
	void RAS_OpenGLRasterizer::Exit()
	{

	+ m_storage->Exit();
	+
	glEnable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glClearDepth(1.0);
	@@ -286,7 +315,7 @@
	bool RAS_OpenGLRasterizer::BeginFrame(int drawingmode, double time)
	{
	m_time = time;
	- m_drawingmode = drawingmode;
	+ SetDrawingMode(drawingmode);

	// Blender camera routine destroys the settings
	if (m_drawingmode < KX_SOLID)
	@@ -325,6 +354,8 @@

	if (m_drawingmode == KX_WIREFRAME)
	glDisable(GL_CULL_FACE);
	+
	+ m_storage->SetDrawingMode(drawingmode);
	}

	int RAS_OpenGLRasterizer::GetDrawingMode()
	@@ -393,7 +424,7 @@
	glBegin(GL_LINE_LOOP);
	glColor4f(m_debugShapes[i].m_color[0],m_debugShapes[i].m_color[1],m_debugShapes[i].m_color[2],1.f);

	- static const MT_Vector3 worldUp(0.0, 0.0, 1.0);
	+ static const MT_Vector3 worldUp(0.,0.,1.);
	MT_Vector3 norm = m_debugShapes[i].m_param;
	MT_Matrix3x3 tr;
	if (norm.fuzzyZero() \|\| norm == worldUp)
	@@ -414,7 +445,7 @@
	for (int j = 0; j<n; j++)
	{
	MT_Scalar theta = jM_PI2/n;
	- MT_Vector3 pos(cos(theta) * rad, sin(theta) * rad, 0.0);
	+ MT_Vector3 pos(cos(theta)rad, sin(theta)rad, 0.);
	pos = pos*tr;
	pos += m_debugShapes[i].m_pos;
	const MT_Scalar* posPtr = &pos.x();
	@@ -706,258 +737,22 @@
	m_attrib[unit] = coords;
	}

	-void RAS_OpenGLRasterizer::TexCoord(const RAS_TexVert &tv)
	-{
	- int unit;
	-
	- if (GLEW_ARB_multitexture) {
	- for (unit=0; unit<m_texco_num; unit++) {
	- if (tv.getFlag() & RAS_TexVert::SECOND_UV && (int)tv.getUnit() == unit) {
	- glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, tv.getUV2());
	- continue;
	- }
	- switch(m_texco[unit]) {
	- case RAS_TEXCO_ORCO:
	- case RAS_TEXCO_GLOB:
	- glMultiTexCoord3fvARB(GL_TEXTURE0_ARB+unit, tv.getXYZ());
	- 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;
	- }
	- }
	- }
	-
	- 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:
	- glVertexAttrib3fvARB(unit, tv.getXYZ());
	- 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;
	- case RAS_TEXCO_VCOL:
	- glVertexAttrib4ubvARB(unit, tv.getRGBA());
	- break;
	- default:
	- break;
	- }
	- }
	- }
	-
	-}
	-
	void RAS_OpenGLRasterizer::IndexPrimitives(RAS_MeshSlot& ms)
	{
	- IndexPrimitivesInternal(ms, false);
	+ if (ms.m_pDerivedMesh)
	+ m_failsafe_storage->IndexPrimitives(ms);
	+ else
	+ m_storage->IndexPrimitives(ms);
	}

	void RAS_OpenGLRasterizer::IndexPrimitivesMulti(RAS_MeshSlot& ms)
	{
	- IndexPrimitivesInternal(ms, true);
	+ if (ms.m_pDerivedMesh)
	+ m_failsafe_storage->IndexPrimitivesMulti(ms);
	+ else
	+ m_storage->IndexPrimitivesMulti(ms);
	}

	-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 Image *current_image;
	-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, &current_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;
	-}
	-*/
	-
	-static DMDrawOption CheckTexDM(MTFace *tface, int has_mcol, int matnr)
	-{
	-
	- // index is the original face index, retrieve the polygon
	- if (matnr == current_blmat_nr &&
	- (tface == NULL \|\| tface->tpage == current_image)) {
	- // must handle color.
	- if (current_wireframe)
	- return DM_DRAW_OPTION_NO_MCOL;
	- 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 DM_DRAW_OPTION_NO_MCOL;
	- }
	- if (!has_mcol) {
	- // we have to set the color from the material
	- unsigned char rgba[4];
	- current_polymat->GetMaterialRGBAColor(rgba);
	- glColor4ubv((const GLubyte *)rgba);
	- return DM_DRAW_OPTION_NO_MCOL;
	- }
	- return DM_DRAW_OPTION_NORMAL;
	- }
	- return DM_DRAW_OPTION_SKIP;
	-}
	-
	-void RAS_OpenGLRasterizer::IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi)
	-{
	- bool obcolor = ms.m_bObjectColor;
	- bool wireframe = m_drawingmode <= KX_WIREFRAME;
	- MT_Vector4& rgba = ms.m_RGBAcolor;
	- RAS_MeshSlot::iterator it;
	-
	- 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;
	- // MCol mcol = (MCol)ms.m_pDerivedMesh->getFaceDataArray(ms.m_pDerivedMesh, CD_MCOL); /* UNUSED */
	-
	- // handle two-side
	- if (current_polymat->GetDrawingMode() & RAS_IRasterizer::KX_BACKCULL)
	- this->SetCullFace(true);
	- else
	- this->SetCullFace(false);
	-
	- 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), &current_gpu_attribs);
	- else
	- memset(&current_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_alpha_blend();
	- ms.m_pDerivedMesh->drawFacesGLSL(ms.m_pDerivedMesh, CheckMaterialDM);
	- GPU_set_material_alpha_blend(current_blend_mode);
	- } else {
	- //ms.m_pDerivedMesh->drawMappedFacesTex(ms.m_pDerivedMesh, CheckTexfaceDM, mcol);
	- current_blmat_nr = current_polymat->GetMaterialIndex();
	- current_image = current_polymat->GetBlenderImage();
	- ms.m_pDerivedMesh->drawFacesTex(ms.m_pDerivedMesh, CheckTexDM, NULL, NULL);
	- }
	- return;
	- }
	- // 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;
	-
	- if (it.array->m_type == RAS_DisplayArray::LINE) {
	- // line drawing
	- glBegin(GL_LINES);
	-
	- for (i=0; i<it.totindex; i+=2)
	- {
	- vertex = &it.vertex[it.index[i]];
	- glVertex3fv(vertex->getXYZ());
	-
	- vertex = &it.vertex[it.index[i+1]];
	- glVertex3fv(vertex->getXYZ());
	- }
	-
	- glEnd();
	- }
	- else {
	- // triangle and quad drawing
	- if (it.array->m_type == RAS_DisplayArray::TRIANGLE)
	- glBegin(GL_TRIANGLES);
	- else
	- glBegin(GL_QUADS);
	-
	- for (i=0; i<it.totindex; i+=numvert)
	- {
	- 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());
	- }
	-
	- glVertex3fv(vertex->getXYZ());
	- }
	- }
	-
	- glEnd();
	- }
	- }
	-}
	-
	void RAS_OpenGLRasterizer::SetProjectionMatrix(MT_CmMatrix4x4 &mat)
	{
	glMatrixMode(GL_PROJECTION);
	Index: source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h
	===================================================================
	--- source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h (working copy)
	@@ -41,6 +41,7 @@
	using namespace std;

	#include "RAS_IRasterizer.h"
	+#include "RAS_IStorage.h"
	#include "RAS_MaterialBucket.h"
	#include "RAS_ICanvas.h"

	@@ -115,9 +116,15 @@
	/** Stores the caching information for the last material activated. */
	RAS_IPolyMaterial::TCachingInfo m_materialCachingInfo;

	+ /** Making use of a Strategy desing pattern for storage behavior.
	+ Examples of concrete strategies: Vertex Arrays, VBOs, Immediate Mode*/
	+ int m_storage_type;
	+ RAS_IStorage* m_storage;
	+ RAS_IStorage* m_failsafe_storage; //So derived mesh can use immediate mode
	+
	public:
	double GetTime();
	- RAS_OpenGLRasterizer(RAS_ICanvas* canv);
	+ RAS_OpenGLRasterizer(RAS_ICanvas* canv, int storage=RAS_AUTO_STORAGE);
	virtual ~RAS_OpenGLRasterizer();

	/*enum DrawType
	Index: source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp
	===================================================================
	--- source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_ListRasterizer.cpp (working copy)
	@@ -106,9 +106,8 @@



	-RAS_ListRasterizer::RAS_ListRasterizer(RAS_ICanvas* canvas, bool useVertexArrays, bool lock)
	-: RAS_VAOpenGLRasterizer(canvas, lock),
	- mUseVertexArrays(useVertexArrays),
	+RAS_ListRasterizer::RAS_ListRasterizer(RAS_ICanvas* canvas, bool lock, int storage)
	+: RAS_OpenGLRasterizer(canvas, storage),
	mATI(false)
	{
	if (!strcmp((const char*)glGetString(GL_VENDOR), "ATI Technologies Inc."))
	@@ -238,11 +237,8 @@
	return;
	}
	}
	- // derived mesh cannot use vertex array
	- if (mUseVertexArrays && !ms.m_pDerivedMesh)
	- RAS_VAOpenGLRasterizer::IndexPrimitives(ms);
	- else
	- RAS_OpenGLRasterizer::IndexPrimitives(ms);
	+
	+ RAS_OpenGLRasterizer::IndexPrimitives(ms);

	if (ms.m_bDisplayList) {
	localSlot->EndList();
	@@ -267,13 +263,7 @@
	}
	}

	- // workaround: note how we do not use vertex arrays for making display
	- // lists, since glVertexAttribPointerARB doesn't seem to work correct
	- // in display lists on ATI? either a bug in the driver or in Blender ..
	- if (mUseVertexArrays && !mATI && !ms.m_pDerivedMesh)
	- RAS_VAOpenGLRasterizer::IndexPrimitivesMulti(ms);
	- else
	- RAS_OpenGLRasterizer::IndexPrimitivesMulti(ms);
	+ RAS_OpenGLRasterizer::IndexPrimitivesMulti(ms);

	if (ms.m_bDisplayList) {
	localSlot->EndList();
	@@ -283,29 +273,17 @@

	bool RAS_ListRasterizer::Init(void)
	{
	- if (mUseVertexArrays) {
	- return RAS_VAOpenGLRasterizer::Init();
	- } else {
	- return RAS_OpenGLRasterizer::Init();
	- }
	+ return RAS_OpenGLRasterizer::Init();
	}

	void RAS_ListRasterizer::SetDrawingMode(int drawingmode)
	{
	- if (mUseVertexArrays) {
	- RAS_VAOpenGLRasterizer::SetDrawingMode(drawingmode);
	- } else {
	- RAS_OpenGLRasterizer::SetDrawingMode(drawingmode);
	- }
	+ RAS_OpenGLRasterizer::SetDrawingMode(drawingmode);
	}

	void RAS_ListRasterizer::Exit()
	{
	- if (mUseVertexArrays) {
	- RAS_VAOpenGLRasterizer::Exit();
	- } else {
	- RAS_OpenGLRasterizer::Exit();
	- }
	+ RAS_OpenGLRasterizer::Exit();
	}

	// eof
	Index: source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt
	===================================================================
	--- source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_OpenGLRasterizer/CMakeLists.txt (working copy)
	@@ -46,12 +46,17 @@
	RAS_GLExtensionManager.cpp
	RAS_ListRasterizer.cpp
	RAS_OpenGLRasterizer.cpp
	- RAS_VAOpenGLRasterizer.cpp
	+ RAS_StorageIM.cpp
	+ RAS_StorageVA.cpp
	+ RAS_StorageVBO.cpp

	RAS_GLExtensionManager.h
	+ RAS_IStorage.h
	RAS_ListRasterizer.h
	RAS_OpenGLRasterizer.h
	- RAS_VAOpenGLRasterizer.h
	+ RAS_StorageIM.h
	+ RAS_StorageVA.h
	+ RAS_StorageVBO.h
	)

	add_definitions(-DGLEW_STATIC)
	Index: source/gameengine/Rasterizer/RAS_MeshObject.h
	===================================================================
	--- source/gameengine/Rasterizer/RAS_MeshObject.h (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_MeshObject.h (working copy)
	@@ -46,6 +46,7 @@
	#include "MT_Transform.h"

	#include "CTR_HashedPtr.h"
	+#include <map>

	struct Mesh;
	class RAS_Deformer;
	@@ -71,6 +72,15 @@
	struct polygonSlot;
	struct backtofront;
	struct fronttoback;
	+
	+ /* vbo data */
	+ std::map<int,int> vbo_vertex_id;
	+ std::map<int,int> vbo_normal_id;
	+ std::map<int,int> vbo_color_id;
	+ std::map<int,int> vbo_tangent_id;
	+ std::map<int,int> vbo_uv1_id;
	+ std::map<int,int> vbo_uv2_id;
	+ std::map<int,int> vbo_index_id;

	protected:
	vector<int> m_cacheWeightIndex;
	@@ -82,6 +92,9 @@
	RAS_MeshObject(Mesh* mesh);
	virtual ~RAS_MeshObject();

	+ /* vbo data */
	+ void SetVBOId(int index, char* name, int id);
	+ int GetVBOId(int index, char* name);

	// for shape keys,
	void CheckWeightCache(struct Object* obj);
	Index: source/gameengine/Rasterizer/RAS_MaterialBucket.cpp
	===================================================================
	--- source/gameengine/Rasterizer/RAS_MaterialBucket.cpp (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_MaterialBucket.cpp (working copy)
	@@ -605,7 +605,8 @@

	if (ms.m_pDeformer)
	{
	- ms.m_pDeformer->Apply(m_material);
	+ if (ms.m_pDeformer->Apply(m_material));
	+ ms.m_mesh->SetMeshModified(true);
	// KX_ReInstanceShapeFromMesh(ms.m_mesh); // Recompute the physics mesh. (Can't call KX_* from RAS_)
	}

	@@ -648,8 +649,8 @@
	else
	rasty->IndexPrimitives(ms);

	- if (rasty->QueryLists())
	- if (ms.m_DisplayList)
	+ //if (rasty->QueryLists())//??
	+ //if (ms.m_DisplayList)//??
	ms.m_mesh->SetMeshModified(false);

	rendertools->PopMatrix();
	Index: source/gameengine/Rasterizer/RAS_MeshObject.cpp
	===================================================================
	--- source/gameengine/Rasterizer/RAS_MeshObject.cpp (revision 45937)
	+++ source/gameengine/Rasterizer/RAS_MeshObject.cpp (working copy)
	@@ -108,6 +108,7 @@
	: m_bModified(true),
	m_bMeshModified(true),
	m_mesh(mesh)
	+
	{
	if (m_mesh && m_mesh->key)
	{
	@@ -155,7 +156,27 @@
	//}


	+void RAS_MeshObject::SetVBOId(int index, char* name, int id) {
	+ if (strcmp(name, "vertex") == 0) this->vbo_vertex_id[index] = id;
	+ if (strcmp(name, "normal") == 0) this->vbo_normal_id[index] = id;
	+ if (strcmp(name, "color") == 0) this->vbo_color_id[index] = id;
	+ if (strcmp(name, "tangent") == 0) this->vbo_tangent_id[index] = id;
	+ if (strcmp(name, "uv1") == 0) this->vbo_uv1_id[index] = id;
	+ if (strcmp(name, "uv2") == 0) this->vbo_uv2_id[index] = id;
	+ if (strcmp(name, "index") == 0) this->vbo_index_id[index] = id;
	+}

	+int RAS_MeshObject::GetVBOId(int index, char* name) {
	+ if (strcmp(name, "vertex") == 0) return this->vbo_vertex_id[index];
	+ if (strcmp(name, "normal") == 0) return this->vbo_normal_id[index];
	+ if (strcmp(name, "color") == 0) return this->vbo_color_id[index];
	+ if (strcmp(name, "tangent") == 0) return this->vbo_tangent_id[index];
	+ if (strcmp(name, "uv1") == 0) return this->vbo_uv1_id[index];
	+ if (strcmp(name, "uv2") == 0) return this->vbo_uv2_id[index];
	+ if (strcmp(name, "index") == 0) return this->vbo_index_id[index];
	+}
	+
	+
	int RAS_MeshObject::NumMaterials()
	{
	return m_materials.size();
	Index: source/blender/makesdna/DNA_scene_types.h
	===================================================================
	--- source/blender/makesdna/DNA_scene_types.h (revision 45937)
	+++ source/blender/makesdna/DNA_scene_types.h (working copy)
	@@ -619,8 +619,9 @@
	short mode, matmode;
	short occlusionRes; /* resolution of occlusion Z buffer in pixel */
	short physicsEngine;
	- short exitkey, pad;
	+ short exitkey/, pad/;
	short ticrate, maxlogicstep, physubstep, maxphystep;
	+ short raster_storage;
	short obstacleSimulation, pad1;
	float levelHeight;
	} GameData;
	@@ -642,6 +643,12 @@
	#define WOPHY_NONE 0
	#define WOPHY_BULLET 5

	+ /* Render storage */
	+#define RAS_STORE_AUTO 0
	+#define RAS_STORE_IMMEDIATE 1
	+#define RAS_STORE_VA 2
	+#define RAS_STORE_VBO 3
	+
	/* obstacleSimulation */
	#define OBSTSIMULATION_NONE 0
	#define OBSTSIMULATION_TOI_rays 1
	Index: source/blender/makesrna/intern/rna_scene.c
	===================================================================
	--- source/blender/makesrna/intern/rna_scene.c (revision 45937)
	+++ source/blender/makesrna/intern/rna_scene.c (working copy)
	@@ -2337,6 +2337,13 @@
	{GAME_MAT_GLSL, "GLSL", 0, "GLSL", "OpenGL shading language shaders"},
	{0, NULL, 0, NULL, NULL}};

	+static EnumPropertyItem storage_items[] ={
	+ {RAS_STORE_AUTO, "AUTO", 0, "Auto Select", "Chooses the best supported mode"},
	+ {RAS_STORE_IMMEDIATE, "IMMEDIATE", 0, "Immediate Mode", "Slowest performance, requires OpenGL (any version)"},
	+ {RAS_STORE_VA, "VERTEX_ARRAY", 0, "Vertex Arrays", "Moderate performance, requires at least OpenGL 1.1"},
	+ {RAS_STORE_VBO, "VERTEX_BUFFER_OBJECT", 0, "Vertex Buffer Objects", "Best performance, requires at least OpenGL 1.4"},
	+ {0, NULL, 0, NULL, NULL}};
	+
	static EnumPropertyItem obstacle_simulation_items[] = {
	{OBSTSIMULATION_NONE, "NONE", 0, "None", ""},
	{OBSTSIMULATION_TOI_rays, "RVO_RAYS", 0, "RVO (rays)", ""},
	@@ -2354,6 +2361,12 @@
	RNA_def_property_ui_text(prop, "Resolution X", "Number of horizontal pixels in the screen");
	RNA_def_property_update(prop, NC_SCENE, NULL);

	+ prop = RNA_def_property(srna, "raster_storage", PROP_ENUM, PROP_NONE);
	+ RNA_def_property_enum_sdna(prop, NULL, "raster_storage");
	+ RNA_def_property_enum_items(prop, storage_items);
	+ RNA_def_property_ui_text(prop, "Storage", "Sets the storage mode used by the rasterizer");
	+ RNA_def_property_update(prop, NC_SCENE, NULL);
	+
	prop = RNA_def_property(srna, "resolution_y", PROP_INT, PROP_NONE);
	RNA_def_property_int_sdna(prop, NULL, "yplay");
	RNA_def_property_range(prop, 4, 10000);

File Metadata

Mime Type: text/x-diff
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 24/0a/cb5ef70f95493deb32b765570af8

vbo_patch.diffPublicActions

vbo_patch.diffView Options

File Metadata

Event Timeline

vbo_patch.diff
Public
Actions

vbo_patch.diff
View Options