diff options
| author | Erwin Coumans <blender@erwincoumans.com> | 2006-01-06 06:46:54 +0300 |
|---|---|---|
| committer | Erwin Coumans <blender@erwincoumans.com> | 2006-01-06 06:46:54 +0300 |
| commit | 2e6d57618232b8b4ce8e5afe84fd278041cbbbfe (patch) | |
| tree | c0f05e6b59aada420dd600f1138e9149b97d9e9d /source/gameengine/Rasterizer | |
| parent | ef520a8cc9e863aa234be0ee60d1038e7ec8fc44 (diff) | |
Sorry to break the cvs-closed status, so if you really need to make a new 2.40 build, just disable the game engine if it doesn't compile for a platform. Again, sorry if this breaks non-windows platforms, but I hope people help to get this amazing fix working for all platforms. Armature-fixing contribution from Snailrose. Also lots of cool things from Snailrose and Lagan.
Armatures are back
Split screen
Double sided lightning
Ambient lighting
Alpha test
Material IPO support (one per object atm)
Blender materials
GLSL shaders - Python access
Up to three texture samplers from the material panel ( 2D & Cube map )
Python access to a second set of uv coordinates
See http://www.elysiun.com/forum/viewtopic.php?t=58057
Diffstat (limited to 'source/gameengine/Rasterizer')
13 files changed, 1694 insertions, 39 deletions
diff --git a/source/gameengine/Rasterizer/RAS_BucketManager.cpp b/source/gameengine/Rasterizer/RAS_BucketManager.cpp index 4ce072dd7cc..091e78c7b28 100644 --- a/source/gameengine/Rasterizer/RAS_BucketManager.cpp +++ b/source/gameengine/Rasterizer/RAS_BucketManager.cpp @@ -141,10 +141,17 @@ void RAS_BucketManager::Renderbuckets( } for (bucket = m_MaterialBuckets.begin(); bucket != m_MaterialBuckets.end(); ++bucket) + { + if((*bucket)->GetPolyMaterial()->IsZSort()) + rasty->SetAlphaTest(true); + else + rasty->SetAlphaTest(false); + (*bucket)->Render(cameratrans,rasty,rendertools); - + } + rasty->SetAlphaTest(false); + RenderAlphaBuckets(cameratrans, rasty, rendertools); - RAS_MaterialBucket::EndFrame(); } diff --git a/source/gameengine/Rasterizer/RAS_CameraData.h b/source/gameengine/Rasterizer/RAS_CameraData.h index a4245025f2a..69a43dd64e9 100644 --- a/source/gameengine/Rasterizer/RAS_CameraData.h +++ b/source/gameengine/Rasterizer/RAS_CameraData.h @@ -38,12 +38,23 @@ struct RAS_CameraData float m_clipstart; float m_clipend; bool m_perspective; - - RAS_CameraData(float lens = 35., float clipstart = 0.1, float clipend = 100., bool perspective = true) : + bool m_viewport; + int m_viewportleft; + int m_viewportbottom; + int m_viewportright; + int m_viewporttop; + + RAS_CameraData(float lens = 35., float clipstart = 0.1, float clipend = 100., bool perspective = true, + bool viewport = false, int viewportleft = 0, int viewportbottom = 0, int viewportright = 0, int viewporttop = 0) : m_lens(lens), m_clipstart(clipstart), m_clipend(clipend), - m_perspective(perspective) + m_perspective(perspective), + m_viewport(viewport), + m_viewportleft(viewportleft), + m_viewportbottom(viewportbottom), + m_viewportright(viewportright), + m_viewporttop(viewporttop) { } }; diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp index 330f964de7b..b5882bd48c4 100644 --- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp +++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp @@ -57,7 +57,10 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname, m_zsort(zsort), m_lightlayer(lightlayer), m_bIsTriangle(bIsTriangle), - m_polymatid(m_newpolymatid++) + m_polymatid(m_newpolymatid++), + m_flag(0), + m_enabled(0), + m_multimode(0) { m_shininess = 35.0; m_specular = MT_Vector3(0.5,0.5,0.5); @@ -68,18 +71,32 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname, bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const { - return ( - this->m_tile == lhs.m_tile && - this->m_tilexrep == lhs.m_tilexrep && - this->m_tileyrep == lhs.m_tileyrep && - this->m_transparant == lhs.m_transparant && - this->m_zsort == lhs.m_zsort && - this->m_drawingmode == lhs.m_drawingmode && - this->m_bIsTriangle == lhs.m_bIsTriangle && - this->m_lightlayer == lhs.m_lightlayer && + if(m_flag &RAS_BLENDERMAT) + { + return ( + this->m_multimode == lhs.m_multimode && + this->m_flag == lhs.m_flag && + this->m_drawingmode == lhs.m_drawingmode && + this->m_lightlayer == lhs.m_lightlayer && this->m_texturename.hash() == lhs.m_texturename.hash() && this->m_materialname.hash() == lhs.m_materialname.hash() - ); + ); + } + else + { + return ( + this->m_tile == lhs.m_tile && + this->m_tilexrep == lhs.m_tilexrep && + this->m_tileyrep == lhs.m_tileyrep && + this->m_transparant == lhs.m_transparant && + this->m_zsort == lhs.m_zsort && + this->m_drawingmode == lhs.m_drawingmode && + this->m_bIsTriangle == lhs.m_bIsTriangle && + this->m_lightlayer == lhs.m_lightlayer && + this->m_texturename.hash() == lhs.m_texturename.hash() && + this->m_materialname.hash() == lhs.m_materialname.hash() + ); + } } bool RAS_IPolyMaterial::Less(const RAS_IPolyMaterial& rhs) const @@ -130,4 +147,14 @@ const STR_String& RAS_IPolyMaterial::GetTextureName() const return m_texturename; } +const unsigned int RAS_IPolyMaterial::GetFlag() const +{ + return m_flag; +} +const unsigned int RAS_IPolyMaterial::GetEnabled() const +{ + return m_enabled; +} + + unsigned int RAS_IPolyMaterial::m_newpolymatid = 0; diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h index b039b51dd8b..3e296c2b88b 100644 --- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h +++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h @@ -43,6 +43,20 @@ class RAS_IRasterizer; +enum MaterialProps +{ + RAS_ZSORT =1, + RAS_TRANSPARENT =2, + RAS_TRIANGLE =4, + RAS_MULTITEX =8, + RAS_MULTILIGHT =16, + RAS_BLENDERMAT =32, + RAS_GLSHADER =64, + RAS_AUTOGEN =128, + RAS_NORMAL =256, + RAS_DEFMULTI =512 +}; + /** * Material properties. */ @@ -52,18 +66,21 @@ class RAS_IPolyMaterial protected: STR_HashedString m_texturename; STR_HashedString m_materialname; //also needed for touchsensor - int m_tile; - int m_tilexrep,m_tileyrep; - int m_drawingmode; // tface->mode - bool m_transparant; - bool m_zsort; - int m_lightlayer; - bool m_bIsTriangle; + int m_tile; + int m_tilexrep,m_tileyrep; + int m_drawingmode; // tface->mode + bool m_transparant; + bool m_zsort; + int m_lightlayer; + bool m_bIsTriangle; unsigned int m_polymatid; - static unsigned int m_newpolymatid; - + + // will move... + unsigned int m_flag;//MaterialProps + unsigned int m_enabled;// enabled for this mat + int m_multimode; // sum of values public: MT_Vector3 m_diffuse; @@ -124,6 +141,14 @@ public: int GetDrawingMode() const; const STR_String& GetMaterialName() const; const STR_String& GetTextureName() const; + const unsigned int GetFlag() const; + const unsigned int GetEnabled() const; + + /* + * PreCalculate texture gen + */ + virtual void OnConstruction(){} + }; inline bool operator ==( const RAS_IPolyMaterial & rhs,const RAS_IPolyMaterial & lhs) diff --git a/source/gameengine/Rasterizer/RAS_IRasterizer.h b/source/gameengine/Rasterizer/RAS_IRasterizer.h index 03c7e1d5116..68a9429d066 100644 --- a/source/gameengine/Rasterizer/RAS_IRasterizer.h +++ b/source/gameengine/Rasterizer/RAS_IRasterizer.h @@ -219,6 +219,25 @@ public: bool useObjectColor, const MT_Vector4& rgbacolor)=0; + virtual void IndexPrimitivesMulti( + const vecVertexArray& vertexarrays, + const vecIndexArrays & indexarrays, + int mode, + class RAS_IPolyMaterial* polymat, + class RAS_IRenderTools* rendertools, + bool useObjectColor, + const MT_Vector4& rgbacolor)=0; + + virtual void IndexPrimitivesMulti_Ex( + const vecVertexArray& vertexarrays, + const vecIndexArrays & indexarrays, + int mode, + class RAS_IPolyMaterial* polymat, + class RAS_IRenderTools* rendertools, + bool useObjectColor, + const MT_Vector4& rgbacolor)=0; + + virtual void SetProjectionMatrix(MT_CmMatrix4x4 & mat)=0; /* This one should become our final version, methinks. */ /** @@ -329,6 +348,22 @@ public: float difZ, float diffuse)=0; /** + * Sets the emissive colour component of the lighting equation. + */ + virtual void SetEmissive(float eX, + float eY, + float eZ, + float e + )=0; + + virtual void SetAmbientColor(float red, float green, float blue)=0; + virtual void SetAmbient(float factor)=0; + /** + * Sets alpha testing + */ + virtual void SetAlphaTest(bool enable)=0; + + /** * Sets a polygon offset. z depth will be: z1 = mult*z0 + add */ virtual void SetPolygonOffset(float mult, float add) = 0; diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp index 7f9f5b455ba..b1d32326048 100644 --- a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp +++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp @@ -177,7 +177,13 @@ bool RAS_MaterialBucket::ActivateMaterial(const MT_Transform& cameratrans, RAS_I if (!rasty->SetMaterial(*m_material)) return false; - bool dolights = m_material->GetDrawingMode()&16; + bool dolights = false; + const unsigned int flag = m_material->GetFlag(); + + if( flag & RAS_BLENDERMAT) + dolights = flag &RAS_MULTILIGHT; + else + dolights = m_material->GetDrawingMode()&16; if ((rasty->GetDrawingMode() <= RAS_IRasterizer::KX_SOLID) || !dolights) { @@ -229,6 +235,35 @@ void RAS_MaterialBucket::RenderMeshSlot(const MT_Transform& cameratrans, RAS_IRa ms.m_RGBAcolor); } + + // for using glMultiTexCoord + else if(m_material->GetFlag() & RAS_MULTITEX ) + { + rasty->IndexPrimitivesMulti( + ms.m_mesh->GetVertexCache(m_material), + ms.m_mesh->GetIndexCache(m_material), + drawmode, + m_material, + rendertools, + ms.m_bObjectColor, + ms.m_RGBAcolor + ); + } + + // for using glMultiTexCoord on deformer + else if(m_material->GetFlag() & RAS_DEFMULTI ) + { + rasty->IndexPrimitivesMulti( + ms.m_mesh->GetVertexCache(m_material), + ms.m_mesh->GetIndexCache(m_material), + drawmode, + m_material, + rendertools, + ms.m_bObjectColor, + ms.m_RGBAcolor + ); + } + // Use the (slower) IndexPrimitives_Ex which can recalc face normals & such // for deformed objects - eventually should be extended to recalc ALL normals else if (ms.m_pDeformer){ diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/ARB_multitexture.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/ARB_multitexture.h new file mode 100644 index 00000000000..acb16cf046f --- /dev/null +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/ARB_multitexture.h @@ -0,0 +1,164 @@ +#ifndef __ARB_MULTITEXTURE_H__ +#define __ARB_MULTITEXTURE_H__ + +/** + Comment out defines GL_... 1, to disable compilation of each extension. + GL_ARB_multitexture is the minimum for using blender material settings. + For best functionality (GL_ARB_multitexture & GL_ARB_texture_env_combine) are needed. +*/ + +/* ---------------------------------------------------------------------------- + GL_ARB_multitexture +---------------------------------------------------------------------------- */ +#ifndef GL_ARB_multitexture + #define GL_ARB_multitexture 1 +#endif + +#ifdef GL_ARB_multitexture + #define GL_TEXTURE0_ARB 0x84C0 + #define GL_TEXTURE1_ARB 0x84C1 + #define GL_TEXTURE2_ARB 0x84C2 + #define GL_TEXTURE3_ARB 0x84C3 + #define GL_TEXTURE4_ARB 0x84C4 + #define GL_TEXTURE5_ARB 0x84C5 + #define GL_TEXTURE6_ARB 0x84C6 + #define GL_TEXTURE7_ARB 0x84C7 + #define GL_TEXTURE8_ARB 0x84C8 + #define GL_TEXTURE9_ARB 0x84C9 + #define GL_TEXTURE10_ARB 0x84CA + #define GL_ACTIVE_TEXTURE_ARB 0x84E0 + #define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 + #define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 +#endif + + +/* ---------------------------------------------------------------------------- + GL_ARB_texture_env_combine +---------------------------------------------------------------------------- */ +#ifndef GL_ARB_texture_env_combine + #define GL_ARB_texture_env_combine 1 +#endif + +#ifdef GL_ARB_texture_env_combine + #define GL_COMBINE_ARB 0x8570 + #define GL_COMBINE_RGB_ARB 0x8571 + #define GL_COMBINE_ALPHA_ARB 0x8572 + #define GL_SOURCE0_RGB_ARB 0x8580 + #define GL_SOURCE1_RGB_ARB 0x8581 + #define GL_SOURCE2_RGB_ARB 0x8582 + #define GL_SOURCE0_ALPHA_ARB 0x8588 + #define GL_SOURCE1_ALPHA_ARB 0x8589 + #define GL_SOURCE2_ALPHA_ARB 0x858A + #define GL_OPERAND0_RGB_ARB 0x8590 + #define GL_OPERAND1_RGB_ARB 0x8591 + #define GL_OPERAND2_RGB_ARB 0x8592 + #define GL_OPERAND0_ALPHA_ARB 0x8598 + #define GL_OPERAND1_ALPHA_ARB 0x8599 + #define GL_OPERAND2_ALPHA_ARB 0x859A + #define GL_RGB_SCALE_ARB 0x8573 + #define GL_ADD_SIGNED_ARB 0x8574 + #define GL_INTERPOLATE_ARB 0x8575 + #define GL_SUBTRACT_ARB 0x84E7 + #define GL_CONSTANT_ARB 0x8576 + #define GL_PRIMARY_COLOR_ARB 0x8577 + #define GL_PREVIOUS_ARB 0x8578 +#endif + +/* ---------------------------------------------------------------------------- + GL_ARB_texture_cube_map +---------------------------------------------------------------------------- */ +#ifndef GL_ARB_texture_cube_map + #define GL_ARB_texture_cube_map 1 +#endif + +#ifdef GL_ARB_texture_cube_map + #define GL_NORMAL_MAP_ARB 0x8511 + #define GL_REFLECTION_MAP_ARB 0x8512 + #define GL_TEXTURE_CUBE_MAP_ARB 0x8513 + #define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514 + #define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515 + #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516 + #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517 + #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518 + #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519 + #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A + #define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B + #define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB 0x851C +#endif + +/* ---------------------------------------------------------------------------- + GL_ARB_shader_objects +---------------------------------------------------------------------------- */ +#ifndef GL_ARB_shader_objects + #define GL_ARB_shader_objects 1 +#endif + +#ifdef GL_ARB_shader_objects + #define GL_PROGRAM_OBJECT_ARB 0x8B40 + #define GL_SHADER_OBJECT_ARB 0x8B48 + #define GL_OBJECT_TYPE_ARB 0x8B4E + #define GL_OBJECT_SUBTYPE_ARB 0x8B4F + #define GL_FLOAT_VEC2_ARB 0x8B50 + #define GL_FLOAT_VEC3_ARB 0x8B51 + #define GL_FLOAT_VEC4_ARB 0x8B52 + #define GL_INT_VEC2_ARB 0x8B53 + #define GL_INT_VEC3_ARB 0x8B54 + #define GL_INT_VEC4_ARB 0x8B55 + #define GL_BOOL_ARB 0x8B56 + #define GL_BOOL_VEC2_ARB 0x8B57 + #define GL_BOOL_VEC3_ARB 0x8B58 + #define GL_BOOL_VEC4_ARB 0x8B59 + #define GL_FLOAT_MAT2_ARB 0x8B5A + #define GL_FLOAT_MAT3_ARB 0x8B5B + #define GL_FLOAT_MAT4_ARB 0x8B5C + #define GL_SAMPLER_1D_ARB 0x8B5D + #define GL_SAMPLER_2D_ARB 0x8B5E + #define GL_SAMPLER_3D_ARB 0x8B5F + #define GL_SAMPLER_CUBE_ARB 0x8B60 + #define GL_SAMPLER_1D_SHADOW_ARB 0x8B61 + #define GL_SAMPLER_2D_SHADOW_ARB 0x8B62 + #define GL_SAMPLER_2D_RECT_ARB 0x8B63 + #define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 + #define GL_OBJECT_DELETE_STATUS_ARB 0x8B80 + #define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81 + #define GL_OBJECT_LINK_STATUS_ARB 0x8B82 + #define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83 + #define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84 + #define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85 + #define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86 + #define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87 + #define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88 +#endif + +/* ---------------------------------------------------------------------------- + GL_ARB_vertex_shader +---------------------------------------------------------------------------- */ +#ifndef GL_ARB_vertex_shader + #define GL_ARB_vertex_shader 1 +#endif + +#ifdef GL_ARB_vertex_shader + #define GL_VERTEX_SHADER_ARB 0x8B31 + #define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A + #define GL_MAX_VARYING_FLOATS_ARB 0x8B4B + #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C + #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D + #define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89 + #define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A +#endif + + +/* ---------------------------------------------------------------------------- + GL_ARB_fragment_shader +---------------------------------------------------------------------------- */ +#ifndef GL_ARB_fragment_shader + #define GL_ARB_fragment_shader 1 +#endif + +#ifdef GL_ARB_fragment_shader + #define GL_FRAGMENT_SHADER_ARB 0x8B30 + #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49 + #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B +#endif + +#endif//__ARB_MULTITEXTURE_H__ diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp index cd37fbec502..71b68815c15 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp @@ -317,7 +317,99 @@ PFNGLPNTRIANGLESIATIPROC glPNTrianglesiATI; PFNGLPNTRIANGLESFATIPROC glPNTrianglesfATI; #endif +BL_EXTInfo RAS_EXT_support; + + +#if defined(GL_ARB_multitexture) +int max_texture_units = 2; + +PFNGLACTIVETEXTUREARBPROC glActiveTextureARB; +PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB; +PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB; +PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB; +PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB; +PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB; +PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB; +PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB; +PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB; +PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB; +PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB; +PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB; +PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB; +PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB; +PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB; +PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB; +PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB; +PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB; +PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB; +PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB; +PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB; +PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB; +PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB; +PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB; +PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB; +PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB; +PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB; +PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB; +PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB; +PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB; +PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB; +PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB; +PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB; +PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB; +#endif + +#if defined(GL_ARB_shader_objects) +PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; +PFNGLGETHANDLEARBPROC glGetHandleARB; +PFNGLDETACHOBJECTARBPROC glDetachObjectARB; +PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; +PFNGLSHADERSOURCEARBPROC glShaderSourceARB; +PFNGLCOMPILESHADERARBPROC glCompileShaderARB; +PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; +PFNGLATTACHOBJECTARBPROC glAttachObjectARB; +PFNGLLINKPROGRAMARBPROC glLinkProgramARB; +PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; +PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB; +PFNGLUNIFORM1FARBPROC glUniform1fARB; +PFNGLUNIFORM2FARBPROC glUniform2fARB; +PFNGLUNIFORM3FARBPROC glUniform3fARB; +PFNGLUNIFORM4FARBPROC glUniform4fARB; +PFNGLUNIFORM1IARBPROC glUniform1iARB; +PFNGLUNIFORM2IARBPROC glUniform2iARB; +PFNGLUNIFORM3IARBPROC glUniform3iARB; +PFNGLUNIFORM4IARBPROC glUniform4iARB; +PFNGLUNIFORM1FVARBPROC glUniform1fvARB; +PFNGLUNIFORM2FVARBPROC glUniform2fvARB; +PFNGLUNIFORM3FVARBPROC glUniform3fvARB; +PFNGLUNIFORM4FVARBPROC glUniform4fvARB; +PFNGLUNIFORM1IVARBPROC glUniform1ivARB; +PFNGLUNIFORM2IVARBPROC glUniform2ivARB; +PFNGLUNIFORM3IVARBPROC glUniform3ivARB; +PFNGLUNIFORM4IVARBPROC glUniform4ivARB; +PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB; +PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB; +PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB; +PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB; +PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; +PFNGLGETINFOLOGARBPROC glGetInfoLogARB; +PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB; +PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; +PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB; +PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB; +PFNGLGETUNIFORMIVARBPROC glGetUniformivARB; +PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB; +#endif + +#if defined(GL_ARB_vertex_shader) +PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB; +PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB; +PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB; +#endif +#if defined(GL_EXT_blend_color) +PFNGLBLENDCOLOREXTPROC glBlendColorEXT; +#endif } // namespace bgl @@ -335,6 +427,7 @@ static void LinkExtensions() { static bool doDebugMessages = m_debug; extensions = STR_String((const char *) glGetString(GL_EXTENSIONS)).Explode(' '); + RAS_EXT_support = BL_EXTInfo(); #if defined(PFNGLPNTRIANGLESIATIPROC) if (QueryExtension("GL_ATI_pn_triangles")) @@ -351,12 +444,191 @@ static void LinkExtensions() } #endif - if (QueryExtension("GL_EXT_separate_specular_color")) - { - EnableExtension(_GL_EXT_separate_specular_color); - if (doDebugMessages) - std::cout << "Detected GL_EXT_separate_specular_color" << std::endl; - } +#ifdef GL_ARB_texture_env_combine + if (QueryExtension("GL_ARB_texture_env_combine")) + { + EnableExtension(_GL_ARB_texture_env_combine); + RAS_EXT_support._ARB_texture_env_combine = 1; + if (doDebugMessages) + { + std::cout << "Detected GL_ARB_texture_env_combine" << std::endl; + } + } +#endif + +#ifdef GL_ARB_texture_cube_map + if (QueryExtension("GL_ARB_texture_cube_map")) + { + EnableExtension(_GL_ARB_texture_cube_map); + RAS_EXT_support._ARB_texture_cube_map = 1; + if (doDebugMessages) + std::cout << "Detected GL_ARB_texture_cube_map" << std::endl; + } +#endif + +#ifdef GL_ARB_multitexture + if (QueryExtension("GL_ARB_multitexture")) + { + glActiveTextureARB = reinterpret_cast<PFNGLACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glActiveTextureARB")); + glClientActiveTextureARB = reinterpret_cast<PFNGLCLIENTACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glClientActiveTextureARB")); + glMultiTexCoord1dARB = reinterpret_cast<PFNGLMULTITEXCOORD1DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dARB")); + glMultiTexCoord1dvARB = reinterpret_cast<PFNGLMULTITEXCOORD1DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dvARB")); + glMultiTexCoord1fARB = reinterpret_cast<PFNGLMULTITEXCOORD1FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fARB")); + glMultiTexCoord1fvARB = reinterpret_cast<PFNGLMULTITEXCOORD1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fvARB")); + glMultiTexCoord1iARB = reinterpret_cast<PFNGLMULTITEXCOORD1IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1iARB")); + glMultiTexCoord1ivARB = reinterpret_cast<PFNGLMULTITEXCOORD1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1ivARB")); + glMultiTexCoord1sARB = reinterpret_cast<PFNGLMULTITEXCOORD1SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1sARB")); + glMultiTexCoord1svARB = reinterpret_cast<PFNGLMULTITEXCOORD1SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1svARB")); + glMultiTexCoord2dARB = reinterpret_cast<PFNGLMULTITEXCOORD2DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dARB")); + glMultiTexCoord2dvARB = reinterpret_cast<PFNGLMULTITEXCOORD2DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dvARB")); + glMultiTexCoord2fARB = reinterpret_cast<PFNGLMULTITEXCOORD2FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fARB")); + glMultiTexCoord2fvARB = reinterpret_cast<PFNGLMULTITEXCOORD2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fvARB")); + glMultiTexCoord2iARB = reinterpret_cast<PFNGLMULTITEXCOORD2IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2iARB")); + glMultiTexCoord2ivARB = reinterpret_cast<PFNGLMULTITEXCOORD2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2ivARB")); + glMultiTexCoord2sARB = reinterpret_cast<PFNGLMULTITEXCOORD2SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2sARB")); + glMultiTexCoord2svARB = reinterpret_cast<PFNGLMULTITEXCOORD2SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2svARB")); + glMultiTexCoord3dARB = reinterpret_cast<PFNGLMULTITEXCOORD3DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dARB")); + glMultiTexCoord3dvARB = reinterpret_cast<PFNGLMULTITEXCOORD3DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dvARB")); + glMultiTexCoord3fARB = reinterpret_cast<PFNGLMULTITEXCOORD3FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fARB")); + glMultiTexCoord3fvARB = reinterpret_cast<PFNGLMULTITEXCOORD3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fvARB")); + glMultiTexCoord3iARB = reinterpret_cast<PFNGLMULTITEXCOORD3IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3iARB")); + glMultiTexCoord3ivARB = reinterpret_cast<PFNGLMULTITEXCOORD3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3ivARB")); + glMultiTexCoord3sARB = reinterpret_cast<PFNGLMULTITEXCOORD3SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3sARB")); + glMultiTexCoord3svARB = reinterpret_cast<PFNGLMULTITEXCOORD3SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3svARB")); + glMultiTexCoord4dARB = reinterpret_cast<PFNGLMULTITEXCOORD4DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dARB")); + glMultiTexCoord4dvARB = reinterpret_cast<PFNGLMULTITEXCOORD4DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dvARB")); + glMultiTexCoord4fARB = reinterpret_cast<PFNGLMULTITEXCOORD4FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fARB")); + glMultiTexCoord4fvARB = reinterpret_cast<PFNGLMULTITEXCOORD4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fvARB")); + glMultiTexCoord4iARB = reinterpret_cast<PFNGLMULTITEXCOORD4IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4iARB")); + glMultiTexCoord4ivARB = reinterpret_cast<PFNGLMULTITEXCOORD4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4ivARB")); + glMultiTexCoord4sARB = reinterpret_cast<PFNGLMULTITEXCOORD4SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4sARB")); + glMultiTexCoord4svARB = reinterpret_cast<PFNGLMULTITEXCOORD4SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4svARB")); + if (glActiveTextureARB && glClientActiveTextureARB && glMultiTexCoord1dARB && glMultiTexCoord1dvARB && glMultiTexCoord1fARB && glMultiTexCoord1fvARB && glMultiTexCoord1iARB && glMultiTexCoord1ivARB && glMultiTexCoord1sARB && glMultiTexCoord1svARB && glMultiTexCoord2dARB && glMultiTexCoord2dvARB && glMultiTexCoord2fARB && glMultiTexCoord2fvARB && glMultiTexCoord2iARB && glMultiTexCoord2ivARB && glMultiTexCoord2sARB && glMultiTexCoord2svARB && glMultiTexCoord3dARB && glMultiTexCoord3dvARB && glMultiTexCoord3fARB && glMultiTexCoord3fvARB && glMultiTexCoord3iARB && glMultiTexCoord3ivARB && glMultiTexCoord3sARB && glMultiTexCoord3svARB && glMultiTexCoord4dARB && glMultiTexCoord4dvARB && glMultiTexCoord4fARB && glMultiTexCoord4fvARB && glMultiTexCoord4iARB && glMultiTexCoord4ivARB && glMultiTexCoord4sARB && glMultiTexCoord4svARB) { + EnableExtension(_GL_ARB_multitexture); + RAS_EXT_support._ARB_multitexture = 1; + if (doDebugMessages) + std::cout << "Enabled GL_ARB_multitexture" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_multitexture implementation is broken!" << std::endl; + } + } +#endif + + + +#ifdef GL_EXT_blend_color + if (QueryExtension("GL_EXT_blend_color")) + { + glBlendColorEXT = reinterpret_cast<PFNGLBLENDCOLOREXTPROC>(bglGetProcAddress((const GLubyte *) "glBlendColorEXT")); + if (glBlendColorEXT) { + EnableExtension(_GL_EXT_blend_color); + RAS_EXT_support._EXT_blend_color = 1; + if (doDebugMessages) + std::cout << "Enabled GL_EXT_blend_color" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_blend_color implementation is broken!" << std::endl; + } + } +#endif + +#ifdef GL_ARB_shader_objects + if (QueryExtension("GL_ARB_shader_objects")) + { + glDeleteObjectARB = reinterpret_cast<PFNGLDELETEOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteObjectARB")); + glGetHandleARB = reinterpret_cast<PFNGLGETHANDLEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetHandleARB")); + glDetachObjectARB = reinterpret_cast<PFNGLDETACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDetachObjectARB")); + glCreateShaderObjectARB = reinterpret_cast<PFNGLCREATESHADEROBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateShaderObjectARB")); + glShaderSourceARB = reinterpret_cast<PFNGLSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glShaderSourceARB")); + glCompileShaderARB = reinterpret_cast<PFNGLCOMPILESHADERARBPROC>(bglGetProcAddress((const GLubyte *) "glCompileShaderARB")); + glCreateProgramObjectARB = reinterpret_cast<PFNGLCREATEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateProgramObjectARB")); + glAttachObjectARB = reinterpret_cast<PFNGLATTACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glAttachObjectARB")); + glLinkProgramARB = reinterpret_cast<PFNGLLINKPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glLinkProgramARB")); + glUseProgramObjectARB = reinterpret_cast<PFNGLUSEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glUseProgramObjectARB")); + glValidateProgramARB = reinterpret_cast<PFNGLVALIDATEPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glValidateProgramARB")); + glUniform1fARB = reinterpret_cast<PFNGLUNIFORM1FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fARB")); + glUniform2fARB = reinterpret_cast<PFNGLUNIFORM2FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fARB")); + glUniform3fARB = reinterpret_cast<PFNGLUNIFORM3FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fARB")); + glUniform4fARB = reinterpret_cast<PFNGLUNIFORM4FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fARB")); + glUniform1iARB = reinterpret_cast<PFNGLUNIFORM1IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1iARB")); + glUniform2iARB = reinterpret_cast<PFNGLUNIFORM2IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2iARB")); + glUniform3iARB = reinterpret_cast<PFNGLUNIFORM3IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3iARB")); + glUniform4iARB = reinterpret_cast<PFNGLUNIFORM4IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4iARB")); + glUniform1fvARB = reinterpret_cast<PFNGLUNIFORM1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fvARB")); + glUniform2fvARB = reinterpret_cast<PFNGLUNIFORM2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fvARB")); + glUniform3fvARB = reinterpret_cast<PFNGLUNIFORM3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fvARB")); + glUniform4fvARB = reinterpret_cast<PFNGLUNIFORM4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fvARB")); + glUniform1ivARB = reinterpret_cast<PFNGLUNIFORM1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1ivARB")); + glUniform2ivARB = reinterpret_cast<PFNGLUNIFORM2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2ivARB")); + glUniform3ivARB = reinterpret_cast<PFNGLUNIFORM3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3ivARB")); + glUniform4ivARB = reinterpret_cast<PFNGLUNIFORM4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4ivARB")); + glUniformMatrix2fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix2fvARB")); + glUniformMatrix3fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix3fvARB")); + glUniformMatrix4fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix4fvARB")); + glGetObjectParameterfvARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterfvARB")); + glGetObjectParameterivARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterivARB")); + glGetInfoLogARB = reinterpret_cast<PFNGLGETINFOLOGARBPROC>(bglGetProcAddress((const GLubyte *) "glGetInfoLogARB")); + glGetAttachedObjectsARB = reinterpret_cast<PFNGLGETATTACHEDOBJECTSARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttachedObjectsARB")); + glGetUniformLocationARB = reinterpret_cast<PFNGLGETUNIFORMLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformLocationARB")); + glGetActiveUniformARB = reinterpret_cast<PFNGLGETACTIVEUNIFORMARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveUniformARB")); + glGetUniformfvARB = reinterpret_cast<PFNGLGETUNIFORMFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformfvARB")); + glGetUniformivARB = reinterpret_cast<PFNGLGETUNIFORMIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformivARB")); + glGetShaderSourceARB = reinterpret_cast<PFNGLGETSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetShaderSourceARB")); + if (glDeleteObjectARB && glGetHandleARB && glDetachObjectARB && glCreateShaderObjectARB && glShaderSourceARB && glCompileShaderARB && glCreateProgramObjectARB && glAttachObjectARB && glLinkProgramARB && glUseProgramObjectARB && glValidateProgramARB && glUniform1fARB && glUniform2fARB && glUniform3fARB && glUniform4fARB && glUniform1iARB && glUniform2iARB && glUniform3iARB && glUniform4iARB && glUniform1fvARB && glUniform2fvARB && glUniform3fvARB && glUniform4fvARB && glUniform1ivARB && glUniform2ivARB && glUniform3ivARB && glUniform4ivARB && glUniformMatrix2fvARB && glUniformMatrix3fvARB && glUniformMatrix4fvARB && glGetObjectParameterfvARB && glGetObjectParameterivARB && glGetInfoLogARB && glGetAttachedObjectsARB && glGetUniformLocationARB && glGetActiveUniformARB && glGetUniformfvARB && glGetUniformivARB && glGetShaderSourceARB) { + EnableExtension(_GL_ARB_shader_objects); + RAS_EXT_support._ARB_shader_objects =1; + if (doDebugMessages) + std::cout << "Enabled GL_ARB_shader_objects" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_shader_objects implementation is broken!" << std::endl; + } + } +#endif + +#ifdef GL_ARB_vertex_shader + if (QueryExtension("GL_ARB_vertex_shader")) + { + glBindAttribLocationARB = reinterpret_cast<PFNGLBINDATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glBindAttribLocationARB")); + glGetActiveAttribARB = reinterpret_cast<PFNGLGETACTIVEATTRIBARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveAttribARB")); + glGetAttribLocationARB = reinterpret_cast<PFNGLGETATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttribLocationARB")); + if (glBindAttribLocationARB && glGetActiveAttribARB && glGetAttribLocationARB) { + EnableExtension(_GL_ARB_vertex_shader); + RAS_EXT_support._ARB_vertex_shader = 1; + if (doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_shader" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_shader implementation is broken!" << std::endl; + } + } +#endif + +#ifdef GL_ARB_fragment_shader + if (QueryExtension("GL_ARB_fragment_shader")) + { + EnableExtension(_GL_ARB_fragment_shader); + RAS_EXT_support._ARB_fragment_shader = 1; + if (doDebugMessages) + std::cout << "Detected GL_ARB_fragment_shader" << std::endl; + } +#endif + + +#ifdef GL_EXT_texture3D + if (QueryExtension("GL_EXT_texture3D")) + { + /* not using 3d textures... but, using GL_TEXTURE_WRAP_R_EXT*/ + EnableExtension(_GL_EXT_texture3D); + RAS_EXT_support._EXT_texture3D = 1; + if (doDebugMessages) + std::cout << "Enabled GL_EXT_texture3D" << std::endl; + } +#endif + + if (QueryExtension("GL_EXT_separate_specular_color")) + { + EnableExtension(_GL_EXT_separate_specular_color); + if (doDebugMessages) + std::cout << "Detected GL_EXT_separate_specular_color" << std::endl; + } doDebugMessages = false; } diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h index a8ca69950af..5fd94ae53b7 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h @@ -32,6 +32,10 @@ #ifndef __RAS_GLEXTENSIONMANAGER_H__ #define __RAS_GLEXTENSIONMANAGER_H__ +#ifndef APIENTRY +#define APIENTRY +#endif + #ifdef __APPLE__ #include <OpenGL/gl.h> #else @@ -39,6 +43,7 @@ #endif #include "EXT_separate_specular_color.h" +#include "ARB_Multitexture.h" namespace bgl { @@ -369,6 +374,209 @@ extern PFNGLPNTRIANGLESIATIPROC glPNTrianglesiATI; extern PFNGLPNTRIANGLESFATIPROC glPNTrianglesfATI; #endif + +// quick runtime checks +typedef struct BL_EXTInfo +{ + BL_EXTInfo(): + _ARB_multitexture(0), + _ARB_texture_env_combine(0), + _EXT_blend_color(0), + _ARB_texture_cube_map(0), + _ARB_shader_objects(0), + _ARB_vertex_shader(0), + _ARB_fragment_shader(0), + _EXT_texture3D(0) + { + // + } + bool _ARB_multitexture; + bool _ARB_texture_env_combine; + bool _EXT_blend_color; + bool _ARB_texture_cube_map; + bool _ARB_shader_objects; + bool _ARB_vertex_shader; + bool _ARB_fragment_shader; + bool _EXT_texture3D; +}BL_EXTInfo; + +extern BL_EXTInfo RAS_EXT_support; + + +#ifdef GL_EXT_blend_color +typedef void (APIENTRY* PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +extern PFNGLBLENDCOLOREXTPROC glBlendColorEXT; +#endif + +#ifdef GL_ARB_multitexture +extern int max_texture_units; +typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); +typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); +typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); + + +extern PFNGLACTIVETEXTUREARBPROC glActiveTextureARB; +extern PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB; +extern PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB; +extern PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB; +extern PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB; +extern PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB; +extern PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB; +extern PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB; +extern PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB; +extern PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB; +extern PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB; +extern PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB; +extern PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB; +extern PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB; +extern PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB; +extern PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB; +extern PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB; +extern PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB; +extern PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB; +extern PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB; +extern PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB; +extern PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB; +extern PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB; +extern PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB; +extern PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB; +extern PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB; +extern PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB; +extern PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB; +extern PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB; +extern PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB; +extern PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB; +extern PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB; +extern PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB; +extern PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB; +#endif + + +#ifdef GL_ARB_shader_objects +typedef char GLcharARB; +typedef unsigned int GLhandleARB; +typedef void (APIENTRY* PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj); +typedef GLhandleARB (APIENTRY* PFNGLGETHANDLEARBPROC) (GLenum pname); +typedef void (APIENTRY* PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj); +typedef GLhandleARB (APIENTRY* PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType); +typedef void (APIENTRY* PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length); +typedef void (APIENTRY* PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj); +typedef GLhandleARB (APIENTRY* PFNGLCREATEPROGRAMOBJECTARBPROC) (void); +typedef void (APIENTRY* PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj); +typedef void (APIENTRY* PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (APIENTRY* PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj); +typedef void (APIENTRY* PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (APIENTRY* PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0); +typedef void (APIENTRY* PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (APIENTRY* PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (APIENTRY* PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (APIENTRY* PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0); +typedef void (APIENTRY* PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1); +typedef void (APIENTRY* PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (APIENTRY* PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (APIENTRY* PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRY* PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRY* PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRY* PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRY* PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRY* PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRY* PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRY* PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRY* PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRY* PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRY* PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRY* PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat *params); +typedef void (APIENTRY* PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint *params); +typedef void (APIENTRY* PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog); +typedef void (APIENTRY* PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj); +typedef GLint (APIENTRY* PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name); +typedef void (APIENTRY* PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name); +typedef void (APIENTRY* PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat *params); +typedef void (APIENTRY* PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint *params); +typedef void (APIENTRY* PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source); + +extern PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; +extern PFNGLGETHANDLEARBPROC glGetHandleARB; +extern PFNGLDETACHOBJECTARBPROC glDetachObjectARB; +extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; +extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB; +extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB; +extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; +extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB; +extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB; +extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; +extern PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB; +extern PFNGLUNIFORM1FARBPROC glUniform1fARB; +extern PFNGLUNIFORM2FARBPROC glUniform2fARB; +extern PFNGLUNIFORM3FARBPROC glUniform3fARB; +extern PFNGLUNIFORM4FARBPROC glUniform4fARB; +extern PFNGLUNIFORM1IARBPROC glUniform1iARB; +extern PFNGLUNIFORM2IARBPROC glUniform2iARB; +extern PFNGLUNIFORM3IARBPROC glUniform3iARB; +extern PFNGLUNIFORM4IARBPROC glUniform4iARB; +extern PFNGLUNIFORM1FVARBPROC glUniform1fvARB; +extern PFNGLUNIFORM2FVARBPROC glUniform2fvARB; +extern PFNGLUNIFORM3FVARBPROC glUniform3fvARB; +extern PFNGLUNIFORM4FVARBPROC glUniform4fvARB; +extern PFNGLUNIFORM1IVARBPROC glUniform1ivARB; +extern PFNGLUNIFORM2IVARBPROC glUniform2ivARB; +extern PFNGLUNIFORM3IVARBPROC glUniform3ivARB; +extern PFNGLUNIFORM4IVARBPROC glUniform4ivARB; +extern PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB; +extern PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB; +extern PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB; +extern PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB; +extern PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; +extern PFNGLGETINFOLOGARBPROC glGetInfoLogARB; +extern PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB; +extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; +extern PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB; +extern PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB; +extern PFNGLGETUNIFORMIVARBPROC glGetUniformivARB; +extern PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB; +#endif + +#ifdef GL_ARB_vertex_shader +typedef void (APIENTRY* PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB *name); +typedef void (APIENTRY* PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name); +typedef GLint (APIENTRY* PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name); + +extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB; +extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB; +extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB; +#endif + } /* namespace bgl */ diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp index 47c4c4c3e66..fa507b85b1b 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp @@ -177,6 +177,10 @@ bool RAS_OpenGLRasterizer::Init() m_blueback = 0.4375; m_alphaback = 0.0; + m_ambr = 0.0f; + m_ambg = 0.0f; + m_ambb = 0.0f; + glClearColor(m_redback,m_greenback,m_blueback,m_alphaback); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); @@ -187,6 +191,32 @@ bool RAS_OpenGLRasterizer::Init() } +void RAS_OpenGLRasterizer::SetAmbientColor(float red, float green, float blue) +{ + m_ambr = red; + m_ambg = green; + m_ambb = blue; +} + + +void RAS_OpenGLRasterizer::SetAlphaTest(bool enable) +{ + if (enable) + { + glEnable(GL_ALPHA_TEST); + glAlphaFunc(GL_GREATER, 0.6f); + } + else glDisable(GL_ALPHA_TEST); +} + + + +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); +} + void RAS_OpenGLRasterizer::SetBackColor(float red, float green, @@ -1160,6 +1190,768 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa } //for each vertexarray } +void RAS_OpenGLRasterizer::IndexPrimitivesMulti( + const vecVertexArray& vertexarrays, + const vecIndexArrays & indexarrays, + int mode, + class RAS_IPolyMaterial* polymat, + class RAS_IRenderTools* rendertools, + bool useObjectColor, + const MT_Vector4& rgbacolor + ) +{ +#ifdef GL_ARB_multitexture + + GLenum drawmode; + switch (mode) + { + case 0: + drawmode = GL_TRIANGLES; + break; + case 1: + drawmode = GL_LINES; + break; + case 2: + drawmode = GL_QUADS; + break; + default: + drawmode = GL_LINES; + break; + } + + const RAS_TexVert* vertexarray ; + unsigned int numindices,vt; + + for (vt=0;vt<vertexarrays.size();vt++) + { + vertexarray = &((*vertexarrays[vt]) [0]); + const KX_IndexArray & indexarray = (*indexarrays[vt]); + numindices = indexarray.size(); + const unsigned int enabled = polymat->GetEnabled(); + unsigned int unit; + + if (!numindices) + break; + + int vindex=0; + switch (mode) + { + case 1: + { + glBegin(GL_LINES); + vindex=0; + for (unsigned int i=0;i<numindices;i+=2) + { + glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); + glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); + } + glEnd(); + } + break; + case 2: + { + glBegin(GL_QUADS); + vindex=0; + if (useObjectColor) + { + for (unsigned int i=0;i<numindices;i+=4) + { + + glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]); + + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + else + { + for (unsigned int i=0;i<numindices;i+=4) + { + // This looks curiously endian unsafe to me. + // However it depends on the way the colors are packed into + // the m_rgba field of RAS_TexVert + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + glEnd(); + break; + } + case 0: + { + glBegin(GL_TRIANGLES); + vindex=0; + if (useObjectColor) + { + for (unsigned int i=0;i<numindices;i+=3) + { + + glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]); + + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + else + { + for (unsigned int i=0;i<numindices;i+=3) + { + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + glEnd(); + break; + } + default: + { + } + } // switch + } // for each vertexarray +#endif// GL_ARB_multitexture + +} + +void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertexarrays, + const vecIndexArrays & indexarrays, + int mode, + class RAS_IPolyMaterial* polymat, + class RAS_IRenderTools* rendertools, + bool useObjectColor, + const MT_Vector4& rgbacolor + ) +{ +#ifdef GL_ARB_multitexture + bool recalc; + GLenum drawmode; + switch (mode) + { + case 0: + drawmode = GL_TRIANGLES; + break; + case 1: + drawmode = GL_LINES; + break; + case 2: + drawmode = GL_QUADS; + break; + default: + drawmode = GL_LINES; + break; + } + + const RAS_TexVert* vertexarray ; + unsigned int numindices,vt; + + for (vt=0;vt<vertexarrays.size();vt++) + { + vertexarray = &((*vertexarrays[vt]) [0]); + const KX_IndexArray & indexarray = (*indexarrays[vt]); + numindices = indexarray.size(); + const unsigned int enabled = polymat->GetEnabled(); + unsigned int unit; + + if (!numindices) + continue; + + int vindex=0; + switch (mode) + { + case 1: + { + glBegin(GL_LINES); + vindex=0; + for (unsigned int i=0;i<numindices;i+=2) + { + glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); + glVertex3fv(vertexarray[(indexarray[vindex++])].getLocalXYZ()); + } + glEnd(); + } + break; + case 2: + { + glBegin(GL_QUADS); + vindex=0; + if (useObjectColor) + { + for (unsigned int i=0;i<numindices;i+=4) + { + MT_Point3 mv1, mv2, mv3, mv4, fnor; + /* Calc a new face normal */ + + if (vertexarray[(indexarray[vindex])].getFlag() & TV_CALCFACENORMAL) + recalc= true; + else + recalc=false; + + if (recalc){ + mv1 = MT_Point3(vertexarray[(indexarray[vindex])].getLocalXYZ()); + mv2 = MT_Point3(vertexarray[(indexarray[vindex+1])].getLocalXYZ()); + mv3 = MT_Point3(vertexarray[(indexarray[vindex+2])].getLocalXYZ()); + mv4 = MT_Point3(vertexarray[(indexarray[vindex+2])].getLocalXYZ()); + + fnor = (((mv2-mv1).cross(mv3-mv2))+((mv4-mv3).cross(mv1-mv4))).safe_normalized(); + + glNormal3f(fnor[0], fnor[1], fnor[2]); + } + + glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]); + + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + else + { + for (unsigned int i=0;i<numindices;i+=4) + { + // This looks curiously endian unsafe to me. + // However it depends on the way the colors are packed into + // the m_rgba field of RAS_TexVert + MT_Point3 mv1, mv2, mv3, mv4, fnor; + /* Calc a new face normal */ + + if (vertexarray[(indexarray[vindex])].getFlag() & TV_CALCFACENORMAL) + recalc= true; + else + recalc=false; + + + if (recalc){ + mv1 = MT_Point3(vertexarray[(indexarray[vindex])].getLocalXYZ()); + mv2 = MT_Point3(vertexarray[(indexarray[vindex+1])].getLocalXYZ()); + mv3 = MT_Point3(vertexarray[(indexarray[vindex+2])].getLocalXYZ()); + mv4 = MT_Point3(vertexarray[(indexarray[vindex+3])].getLocalXYZ()); + + fnor = (((mv2-mv1).cross(mv3-mv2))+((mv4-mv3).cross(mv1-mv4))).safe_normalized(); + + glNormal3f(fnor[0], fnor[1], fnor[2]); + } + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + glEnd(); + break; + } + case 0: + { + glBegin(GL_TRIANGLES); + vindex=0; + if (useObjectColor) + { + for (unsigned int i=0;i<numindices;i+=3) + { + MT_Point3 mv1, mv2, mv3, fnor; + /* Calc a new face normal */ + + if (vertexarray[(indexarray[vindex])].getFlag() & TV_CALCFACENORMAL) + recalc= true; + else + recalc=false; + + if (recalc){ + mv1 = MT_Point3(vertexarray[(indexarray[vindex])].getLocalXYZ()); + mv2 = MT_Point3(vertexarray[(indexarray[vindex+1])].getLocalXYZ()); + mv3 = MT_Point3(vertexarray[(indexarray[vindex+2])].getLocalXYZ()); + + fnor = ((mv2-mv1).cross(mv3-mv2)).safe_normalized(); + glNormal3f(fnor[0], fnor[1], fnor[2]); + } + + glColor4d(rgbacolor[0], rgbacolor[1], rgbacolor[2], rgbacolor[3]); + + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + else + { + for (unsigned int i=0;i<numindices;i+=3) + { + MT_Point3 mv1, mv2, mv3, fnor; + /* Calc a new face normal */ + + if (vertexarray[(indexarray[vindex])].getFlag() & TV_CALCFACENORMAL) + recalc= true; + else + recalc=false; + + + if (recalc){ + mv1 = MT_Point3(vertexarray[(indexarray[vindex])].getLocalXYZ()); + mv2 = MT_Point3(vertexarray[(indexarray[vindex+1])].getLocalXYZ()); + mv3 = MT_Point3(vertexarray[(indexarray[vindex+2])].getLocalXYZ()); + + fnor = ((mv2-mv1).cross(mv3-mv2)).safe_normalized(); + glNormal3f(fnor[0], fnor[1], fnor[2]); + } + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + + glColor4ubv((const GLubyte *)(vertexarray[(indexarray[vindex])].getRGBA())); + if (!recalc) + glNormal3fv(vertexarray[(indexarray[vindex])].getNormal()); + // ------------------------------ + for(unit =0; unit<enabled; unit++) { + if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV && + vertexarray[(indexarray[vindex])].getUnit() == unit ) + { + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2()); + continue; + } + bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1()); + } + // ------------------------------ + glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ()); + vindex++; + } + } + glEnd(); + break; + } + default: + { + } + + } // switch + } // for each vertexarray +#endif +} + void RAS_OpenGLRasterizer::SetProjectionMatrix(MT_CmMatrix4x4 &mat) @@ -1347,6 +2139,13 @@ void RAS_OpenGLRasterizer::SetDiffuse(float difX,float difY,float difZ,float dif glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse); } +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); +} + + double RAS_OpenGLRasterizer::GetTime() { return m_time; diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h index ad6bdf8c1d1..7e45b1c434b 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h @@ -71,6 +71,10 @@ class RAS_OpenGLRasterizer : public RAS_IRasterizer float m_greenback; float m_blueback; float m_alphaback; + + float m_ambr; + float m_ambg; + float m_ambb; double m_time; MT_CmMatrix4x4 m_viewmatrix; @@ -130,6 +134,8 @@ public: virtual void SetFocalLength(const float focallength); virtual float GetFocalLength(); + virtual void SetAlphaTest(bool enable); + virtual void SwapBuffers(); virtual void IndexPrimitives( const vecVertexArray& vertexarrays, @@ -161,6 +167,25 @@ public: const MT_Vector4& rgbacolor ); + virtual void IndexPrimitivesMulti( + const vecVertexArray& vertexarrays, + const vecIndexArrays & indexarrays, + int mode, + class RAS_IPolyMaterial* polymat, + class RAS_IRenderTools* rendertools, + bool useObjectColor, + const MT_Vector4& rgbacolor); + + virtual void IndexPrimitivesMulti_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 SetProjectionMatrix(MT_CmMatrix4x4 & mat); virtual void SetProjectionMatrix(const MT_Matrix4x4 & mat); virtual void SetViewMatrix( @@ -231,6 +256,15 @@ public: float difZ, float diffuse ); + virtual void SetEmissive(float eX, + float eY, + float eZ, + float e + ); + + virtual void SetAmbientColor(float red, float green, float blue); + virtual void SetAmbient(float factor); + virtual void SetPolygonOffset(float mult, float add); virtual void DrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color) diff --git a/source/gameengine/Rasterizer/RAS_TexVert.cpp b/source/gameengine/Rasterizer/RAS_TexVert.cpp index c68806d500c..9e9b5725b6b 100644 --- a/source/gameengine/Rasterizer/RAS_TexVert.cpp +++ b/source/gameengine/Rasterizer/RAS_TexVert.cpp @@ -45,9 +45,11 @@ RAS_TexVert::RAS_TexVert(const MT_Point3& xyz, { xyz.getValue(m_localxyz); uv.getValue(m_uv1); + uv.getValue(m_uv2); // ..py access SetRGBA(rgba); SetNormal(normal); m_flag = flag; + m_unit = 2; } const MT_Point3& RAS_TexVert::xyz() @@ -78,6 +80,10 @@ void RAS_TexVert::SetUV(const MT_Point2& uv) uv.getValue(m_uv1); } +void RAS_TexVert::SetUV2(const MT_Point2& uv) +{ + uv.getValue(m_uv2); +} void RAS_TexVert::SetRGBA(const unsigned int rgba) @@ -90,6 +96,12 @@ void RAS_TexVert::SetFlag(const short flag) { m_flag = flag; } + +void RAS_TexVert::SetUnit(const unsigned int u) +{ + m_unit = u<=TV_MAX?u:TV_MAX; +} + void RAS_TexVert::SetNormal(const MT_Vector3& normal) { normal.getValue(m_normal); @@ -103,6 +115,12 @@ const float* RAS_TexVert::getUV1 () const return m_uv1; } +const float* RAS_TexVert::getUV2 () const +{ + return m_uv2; +} + + const float* RAS_TexVert::getNormal() const { @@ -137,6 +155,13 @@ short RAS_TexVert::getFlag() const return m_flag; } + +unsigned int RAS_TexVert::getUnit() const +{ + return m_unit; +} + + void RAS_TexVert::getOffsets(void* &xyz, void* &uv1, void* &rgba, void* &normal) const { xyz = (void *) m_localxyz; diff --git a/source/gameengine/Rasterizer/RAS_TexVert.h b/source/gameengine/Rasterizer/RAS_TexVert.h index 650618e1dc1..f58eca7637f 100644 --- a/source/gameengine/Rasterizer/RAS_TexVert.h +++ b/source/gameengine/Rasterizer/RAS_TexVert.h @@ -40,7 +40,10 @@ static MT_Point3 g_pt3; static MT_Point2 g_pt2; -#define TV_CALCFACENORMAL 0x0001 +#define TV_CALCFACENORMAL 0x0001 +#define TV_2NDUV 0x0002 + +#define TV_MAX 3//match Def in BL_Material.h #define RAS_TexVert_INLINE 1 @@ -48,19 +51,21 @@ class RAS_TexVert { float m_localxyz[3]; // 3*4 = 12 - float m_uv1[2]; // 2*4 = 8 + float m_uv1[2]; // 2*4 = 8 + float m_uv2[2]; // 2*4 = 8 ... python access to this set unsigned int m_rgba; // 4 float m_tangent[4]; // 4*2 = 8 float m_normal[3]; // 3*2 = 6 - short m_flag; // 2 - //--------- - // 40 + short m_flag; // 2 + unsigned int m_unit; // 4 + //--------- + // 52 //32 bytes total size, fits nice = 52 = not fit nice. // We'll go for 64 bytes total size - 24 bytes left. - public: short getFlag() const; + unsigned int getUnit() const; RAS_TexVert()// :m_xyz(0,0,0),m_uv(0,0),m_rgba(0) {} @@ -76,7 +81,11 @@ public: const float* getUV1 () const { return m_uv1; }; - + + const float* getUV2 () const { + return m_uv2; + }; + const float* getLocalXYZ() const { return m_localxyz; }; @@ -90,15 +99,19 @@ public: } #else const float* getUV1 () const; + const float* getUV2 () const; const float* getNormal() const; const float* getLocalXYZ() const; const unsigned char* getRGBA() const; #endif void SetXYZ(const MT_Point3& xyz); void SetUV(const MT_Point2& uv); + void SetUV2(const MT_Point2& uv); + void SetRGBA(const unsigned int rgba); void SetNormal(const MT_Vector3& normal); void SetFlag(const short flag); + void SetUnit(const unsigned u); void SetRGBA(const MT_Vector4& rgba); const MT_Point3& xyz(); |