TexFace to Material Settings big patch
authorDalai Felinto <dfelinto@gmail.com>
Mon, 19 Sep 2011 19:55:59 +0000 (19:55 +0000)
committerDalai Felinto <dfelinto@gmail.com>
Mon, 19 Sep 2011 19:55:59 +0000 (19:55 +0000)
Summary:
========
The idea here is to move the texface options into the material panel.
For images with the change please visit:
http://code.blender.org/index.php/2011/09/bge-material-texface-changes

1 - Some of the legacy problems 2.49 and 2.5x has with the texface system:
==========================================================================
1.1) Shadow, Bilboard and Halo are mutual exclusive (in the code), yet you can
select a face to be more than one mode.
1.2) Sort only works for blend Alpha yet it's an option regardless of the
Transparency Blend you pick.
1.3) Shared doesn't affect anything in BGE.
1.4) ObColor only works for Text objects (old bitmap texts) when using Texture
Face Materials. (not address yet, I so far ignored obcolor)

2 - Notes:
============
2.1) Now "Use Face Textures" in material Option panel will work in Multitexture
even if there is no texture channel.

2.2) In FaceTexture mode it will use TexFace all the time, even if you don't
check the "Use Texture Face" option in the UI. It's a matter of decision, since
the code for either way is there. I decided by the solution that makes the
creation of a material fast - in this mode the user doesn't need to mess with
textures or this "Use Texture Face" option at all. I'm not strong in my opinion
here. But I think if we don't have this then what is the point of the Texture
Face mode?

2.3) I kept references for tface only when we need the image, UV or the tiling
setting. It should help later when/if we split the Image and UV layers from the
tface struct  (Campbell and Brecht proposal).

3 - Changes in a Nutshell:
==========================
3.1) "Texture Face" panel (in the Mesh/Object Data panel) no longer exists. Those settings are all part of the material properties, visible when Game Render is set.

3.2) "Texture Face" Shading mode (in the Render panel) is now called “Single Texture”, it needs a material for special settings (e.g. Billboard, Alpha Sort, …).

3.3) New options in the Material Panel
* Shadeless option in the Material panel is now supported for all three Shading modes.
* Physics is now toggleable, this is the old Collision option.
* Two Side (on) is now called Back Culling (off).
* Alpha Sort is one of the Alpha options, together (and mutually exclusive) to Alpha Blend, Alpha Clip, Add and Opaque (i.e. solid).
* Shadow, Billboard and Halo are grouped in the “Face Orientation” property.
* "Face Textures" and "Face Textures Alpha" (under Options) can be used for all but GLSL shading mode (to be supported in GLSL eventually).
* The backend in the game engine is still the same as before. The only changes are in the interface and in the way you need to think your materials. The bottomline is: It’s no longer possible to share materials between faces that do not share the same game properties.

4 - Acknowledgment:
==================
Mike Pan for the design discussions, and testing along the whole development process.
Vitor Balbio for the first hands-on code with the interface changes. That helped me a lot to push me into work on that.
Benoit Bolsee and Brecht van Lommel for patch review (* no one reviewed the whole patch, or the latest iteractions, so I still hold liability for any problems).
Blender artists that gave feedback and helped testing the patch.

Patch review and original documentation can be found here:
http://wiki.blender.org/index.php/User:Dfelinto/TexFace
http://codereview.appspot.com/4289041/

44 files changed:
release/scripts/startup/bl_ui/properties_data_mesh.py
release/scripts/startup/bl_ui/properties_material.py
release/scripts/startup/bl_ui/space_info.py
source/blender/blenkernel/BKE_blender.h
source/blender/blenkernel/BKE_image.h
source/blender/blenkernel/BKE_material.h
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/customdata.c
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/mesh/editmesh_mods.c
source/blender/editors/space_image/space_image.c
source/blender/editors/space_logic/logic_ops.c
source/blender/editors/space_view3d/drawmesh.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_view.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/gpu/GPU_draw.h
source/blender/gpu/GPU_material.h
source/blender/gpu/intern/gpu_draw.c
source/blender/gpu/intern/gpu_material.c
source/blender/makesdna/DNA_material_types.h
source/blender/makesdna/DNA_meshdata_types.h
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_scene.c
source/blender/modifiers/intern/MOD_uvproject.c
source/gameengine/Converter/BL_BlenderDataConversion.cpp
source/gameengine/Ketsji/BL_BlenderShader.cpp
source/gameengine/Ketsji/BL_BlenderShader.h
source/gameengine/Ketsji/BL_Material.cpp
source/gameengine/Ketsji/BL_Material.h
source/gameengine/Ketsji/KX_BlenderMaterial.cpp
source/gameengine/Ketsji/KX_BlenderMaterial.h
source/gameengine/Ketsji/KX_PolygonMaterial.cpp
source/gameengine/Ketsji/KX_PolygonMaterial.h
source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp
source/gameengine/Rasterizer/RAS_IPolygonMaterial.h
source/gameengine/Rasterizer/RAS_IRasterizer.h
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h

index a94a45958dee4f104bbeea539da4ea9638f15049..ff19ece8f94a773a9047c931e0c889e09d0bf2e9 100644 (file)
@@ -289,53 +289,6 @@ class DATA_PT_uv_texture(MeshButtonsPanel, Panel):
             layout.prop(lay, "name")
 
 
-class DATA_PT_texface(MeshButtonsPanel, Panel):
-    bl_label = "Texture Face"
-    COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
-
-    @classmethod
-    def poll(cls, context):
-        obj = context.object
-        return (context.mode == 'EDIT_MESH') and obj and obj.type == 'MESH'
-
-    def draw(self, context):
-        layout = self.layout
-        col = layout.column()
-
-        me = context.mesh
-
-        tf = me.faces.active_tface
-
-        if tf:
-            if context.scene.render.engine != 'BLENDER_GAME':
-                col.label(text="Options only supported in Game Engine")
-
-            split = layout.split()
-            col = split.column()
-
-            col.prop(tf, "use_image")
-            col.prop(tf, "use_light")
-            col.prop(tf, "hide")
-            col.prop(tf, "use_collision")
-
-            col.prop(tf, "use_blend_shared")
-            col.prop(tf, "use_twoside")
-            col.prop(tf, "use_object_color")
-
-            col = split.column()
-
-            col.prop(tf, "use_halo")
-            col.prop(tf, "use_billboard")
-            col.prop(tf, "use_shadow_cast")
-            col.prop(tf, "use_bitmap_text")
-            col.prop(tf, "use_alpha_sort")
-
-            col = layout.column()
-            col.prop(tf, "blend_type")
-        else:
-            col.label(text="No UV Texture")
-
-
 class DATA_PT_vertex_colors(MeshButtonsPanel, Panel):
     bl_label = "Vertex Colors"
     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
index 13ce92f084c37f62733cebac50fc73372cbd9484..68d7d5d4615e23b7c97660f42f7b43a62fb8c367 100644 (file)
@@ -612,9 +612,37 @@ class MATERIAL_PT_flare(MaterialButtonsPanel, Panel):
         col.prop(halo, "flare_subflare_size", text="Subsize")
 
 
-class MATERIAL_PT_physics(MaterialButtonsPanel, Panel):
+class MATERIAL_PT_game_settings(MaterialButtonsPanel, bpy.types.Panel):
+    bl_label = "Game Settings"
+    COMPAT_ENGINES = {'BLENDER_GAME'}
+
+    @classmethod
+    def poll(cls, context):
+         return context.material and (context.scene.render.engine in cls.COMPAT_ENGINES)
+
+    def draw(self, context):
+        layout = self.layout
+        game = context.material.game_settings  # dont use node material
+
+        row = layout.row()
+        row.prop(game, "back_culling")
+        row.prop(game, "invisible")
+        row.prop(game, "text")
+
+        row = layout.row()
+        row.label(text="Alpha Blend:")
+        row.label(text="Face Orientation:")
+        row = layout.row()
+        row.prop(game,"alpha_blend",text="")
+        row.prop(game,"face_orientation",text="")
+
+class MATERIAL_PT_physics(MaterialButtonsPanel, bpy.types.Panel):
     bl_label = "Physics"
     COMPAT_ENGINES = {'BLENDER_GAME'}
+       
+    def draw_header(self, context):
+        game = context.material.game_settings
+        self.layout.prop(game, "physics", text="")
 
     @classmethod
     def poll(cls, context):
@@ -622,6 +650,7 @@ class MATERIAL_PT_physics(MaterialButtonsPanel, Panel):
 
     def draw(self, context):
         layout = self.layout
+        layout.active = context.material.game_settings.physics
 
         phys = context.material.physics  # dont use node material
 
index 7f5a5f231cf9e9874aac26c14d955e5bf99128d4..debe82e7ab2ac6d694ced988fe6233864755835b 100644 (file)
@@ -380,6 +380,7 @@ class INFO_MT_help(Menu):
             layout.operator("wm.console_toggle", icon='CONSOLE')
             layout.separator()
         layout.operator("anim.update_data_paths", text="FCurve/Driver Version fix", icon='HELP')
+        layout.operator("logic.texface_convert", text="TexFace to Material Convert", icon='GAME')
         layout.separator()
         layout.operator("wm.splash", icon='BLENDER')
 
index 742240d53b52a1e3d53b627d1db967516eddd101..333c00c3f2a15f5aa85b0f2259c5470a23942983 100644 (file)
@@ -44,7 +44,7 @@ extern "C" {
  * and keep comment above the defines.
  * Use STRINGIFY() rather than defining with quotes */
 #define BLENDER_VERSION                        259
-#define BLENDER_SUBVERSION             2
+#define BLENDER_SUBVERSION             3
 
 #define BLENDER_MINVERSION             250
 #define BLENDER_MINSUBVERSION  0
index 0c31083a266b5b892fc4b21cb158b4937398deb7..8181ad6421c67058d33cdc2c1b83fd8db16a60aa 100644 (file)
@@ -168,6 +168,9 @@ struct Image *copy_image(struct Image *ima);
 /* merge source into dest, and free source */
 void BKE_image_merge(struct Image *dest, struct Image *source);
 
+/* check if texture has alpha (depth=32) */
+int BKE_image_has_alpha(struct Image *image);
+
 /* image_gen.c */
 void BKE_image_buf_fill_color(unsigned char *rect, float *rect_float, int width, int height, float color[4]);
 void BKE_image_buf_fill_checker(unsigned char *rect, float *rect_float, int height, int width);
index 85b6f8f78fb4613628c7df95a84f11018d415633..b3d24c10ed70d09db441f33bd99fe25cefbe62ed 100644 (file)
@@ -42,6 +42,8 @@ struct Main;
 struct Material;
 struct ID;
 struct Object;
+struct Mesh;
+struct MTFace;
 
 /* materials */
 
@@ -50,6 +52,7 @@ void free_material(struct Material *sc);
 void test_object_materials(struct ID *id);
 void resize_object_material(struct Object *ob, const short totcol);
 void init_material(struct Material *ma);
+struct Material *add_material_main(struct Main *main, const char *name);
 struct Material *add_material(const char *name);
 struct Material *copy_material(struct Material *ma);
 struct Material *localize_material(struct Material *ma);
@@ -101,6 +104,9 @@ void clear_mat_mtex_copybuf(void);
 void copy_mat_mtex_copybuf(struct ID *id);
 void paste_mat_mtex_copybuf(struct ID *id);
 
+/* handle backward compatibility for tface/materials called from doversion (fileload=1) or Help Menu (fileload=0) */   
+int do_version_tface(struct Main *main, int fileload);
+
 #ifdef __cplusplus
 }
 #endif
index 1660ac29217bc19c9be5284b7b8b0d77e0e6da8f..cac7da76e07bc779e2084463cfb8ac208012e16f 100644 (file)
@@ -988,15 +988,12 @@ static void emDM_drawMappedFacesGLSL(DerivedMesh *dm,
        EditFace *efa;
        DMVertexAttribs attribs= {{{0}}};
        GPUVertexAttribs gattribs;
-       MTFace *tf;
-       int transp, new_transp, orig_transp, tfoffset;
+       int tfoffset;
        int i, b, matnr, new_matnr, dodraw, layer;
 
        dodraw = 0;
        matnr = -1;
 
-       transp = GPU_get_material_blend_mode();
-       orig_transp = transp;
        layer = CustomData_get_layer_index(&em->fdata, CD_MTFACE);
        tfoffset = (layer == -1)? -1: em->fdata.layers[layer].offset;
 
@@ -1040,19 +1037,6 @@ static void emDM_drawMappedFacesGLSL(DerivedMesh *dm,
                                DM_vertex_attributes_from_gpu(dm, &gattribs, &attribs);
                }
 
-               if(tfoffset != -1) {
-                       tf = (MTFace*)((char*)efa->data)+tfoffset;
-                       new_transp = tf->transp;
-
-                       if(new_transp != transp) {
-                               if(new_transp == GPU_BLEND_SOLID && orig_transp != GPU_BLEND_SOLID)
-                                       GPU_set_material_blend_mode(orig_transp);
-                               else
-                                       GPU_set_material_blend_mode(new_transp);
-                               transp = new_transp;
-                       }
-               }
-
                if(dodraw) {
                        glBegin(efa->v4?GL_QUADS:GL_TRIANGLES);
                        if (!drawSmooth) {
index 44359a142c9d5996371a84e590dc896ba77dd3a3..e6a472827adaa721620969471d4217efb6e9fddb 100644 (file)
@@ -1063,15 +1063,12 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, vo
        MTFace *tf = dm->getFaceDataArray(dm, CD_MTFACE);
        float (*nors)[3] = dm->getFaceDataArray(dm, CD_NORMAL);
        int a, b, dodraw, matnr, new_matnr;
-       int transp, new_transp, orig_transp;
        int orig, *index = dm->getFaceDataArray(dm, CD_ORIGINDEX);
 
        cdDM_update_normals_from_pbvh(dm);
 
        matnr = -1;
        dodraw = 0;
-       transp = GPU_get_material_blend_mode();
-       orig_transp = transp;
 
        glShadeModel(GL_SMOOTH);
 
@@ -1111,22 +1108,6 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, vo
                                        continue;
                        }
 
-                       if(tf) {
-                               new_transp = tf[a].transp;
-
-                               if(new_transp != transp) {
-                                       glEnd();
-
-                                       if(new_transp == GPU_BLEND_SOLID && orig_transp != GPU_BLEND_SOLID)
-                                               GPU_set_material_blend_mode(orig_transp);
-                                       else
-                                               GPU_set_material_blend_mode(new_transp);
-                                       transp = new_transp;
-
-                                       glBegin(GL_QUADS);
-                               }
-                       }
-
                        if(!smoothnormal) {
                                if(nors) {
                                        glNormal3fv(nors[a]);
@@ -1259,33 +1240,6 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, vo
                                        continue;
                                }
 
-                               if(tf) {
-                                       new_transp = tf[a].transp;
-
-                                       if(new_transp != transp) {
-                                               numfaces = curface - start;
-                                               if( numfaces > 0 ) {
-                                                       if( dodraw ) {
-                                                               if( numdata != 0 ) {
-                                                                       GPU_buffer_unlock(buffer);
-                                                                       GPU_interleaved_attrib_setup(buffer,datatypes,numdata);
-                                                               }
-                                                               glDrawArrays(GL_TRIANGLES,start*3,(curface-start)*3);
-                                                               if( numdata != 0 ) {
-                                                                       varray = GPU_buffer_lock_stream(buffer);
-                                                               }
-                                                       }
-                                               }
-                                               start = curface;
-
-                                               if(new_transp == GPU_BLEND_SOLID && orig_transp != GPU_BLEND_SOLID)
-                                                       GPU_set_material_blend_mode(orig_transp);
-                                               else
-                                                       GPU_set_material_blend_mode(new_transp);
-                                               transp = new_transp;
-                                       }
-                               }
-                               
                                if( numdata != 0 ) {
                                        offset = 0;
                                        if(attribs.totorco) {
index 883f67c30611799888389d54b10138a12257d0ce..30da2e01011fb57749bb866084e2af0ed4b6790f 100644 (file)
@@ -326,7 +326,7 @@ static void layerSwap_tface(void *data, const int *corner_indices)
 static void layerDefault_tface(void *data, int count)
 {
        static MTFace default_tf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}, NULL,
-                                                          0, 0, TF_DYNAMIC, 0, 0};
+                                                          0, 0, TF_DYNAMIC|TF_CONVERTED, 0, 0};
        MTFace *tf = (MTFace*)data;
        int i;
 
index 002cfdbf41a2991b06f1fc95d18bed227a2db146..d764826cd478f7b490db1f9ff54986772316bbf7 100644 (file)
@@ -2290,3 +2290,20 @@ void BKE_image_user_calc_frame(ImageUser *iuser, int cfra, int fieldnr)
        iuser->framenr= framenr;
        if(iuser->ok==0) iuser->ok= 1;
 }
+
+int BKE_image_has_alpha(struct Image *image)
+{
+       ImBuf *ibuf;
+       void *lock;
+       int depth;
+       
+       ibuf= BKE_image_acquire_ibuf(image, NULL, &lock);
+       depth = (ibuf?ibuf->depth:0);
+       BKE_image_release_ibuf(image, lock);
+
+       if (depth == 32)
+               return 1;
+       else
+               return 0;
+}
+
index 2a9e786d13999430c045e81440329f28a6eab969..956d7b01b3bc1a04a0c7398ab2a676e835d1cae2 100644 (file)
@@ -43,6 +43,9 @@
 #include "DNA_curve_types.h"
 #include "DNA_material_types.h"
 #include "DNA_mesh_types.h"
+#include "DNA_meshdata_types.h"
+#include "DNA_customdata_types.h"
+#include "DNA_ID.h"
 #include "DNA_meta_types.h"
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
@@ -56,6 +59,7 @@
 #include "BKE_displist.h"
 #include "BKE_global.h"
 #include "BKE_icons.h"
+#include "BKE_image.h"
 #include "BKE_library.h"
 #include "BKE_main.h"
 #include "BKE_material.h"
@@ -188,6 +192,10 @@ void init_material(Material *ma)
        ma->vol.ms_diff = 1.f;
        ma->vol.ms_intensity = 1.f;
        
+       ma->game.flag=0;
+       ma->game.alpha_blend=0;
+       ma->game.face_orientation=0;
+       
        ma->mode= MA_TRACEBLE|MA_SHADBUF|MA_SHADOW|MA_RAYBIAS|MA_TANGENT_STR|MA_ZTRANSP;
        ma->shade_flag= MA_APPROX_OCCLUSION;
        ma->preview = NULL;
@@ -1468,3 +1476,480 @@ void paste_matcopybuf(Material *ma)
 
        ma->nodetree= ntreeCopyTree(matcopybuf.nodetree);
 }
+
+
+/*********************** texface to material convert functions **********************/
+/* encode all the TF information into a single int */
+int encode_tfaceflag(MTFace *tf, int convertall)
+{
+       /* calculate the flag */
+       int flag = tf->mode;
+
+       /* options that change the material offline render */   
+       if (!convertall) {
+               flag &= ~TF_OBCOL;
+       }
+
+       /* clean flags that are not being converted */
+       flag &= ~TF_TEX;
+       flag &= ~TF_SHAREDVERT;
+       flag &= ~TF_SHAREDCOL;
+       flag &= ~TF_CONVERTED;
+
+       /* light tface flag is ignored in GLSL mode */
+       flag &= ~TF_LIGHT;
+       
+       /* 15 is how big the flag can be - hardcoded here and in decode_tfaceflag() */
+       flag |= tf->transp << 15;
+       
+       /* increase 1 so flag 0 is different than no flag yet */
+       return flag + 1;
+}
+
+/* set the material options based in the tface flag */
+void decode_tfaceflag(Material *ma, int flag, int convertall)
+{
+       int alphablend; 
+       GameSettings *game= &ma->game;
+
+       /* flag is shifted in 1 to make 0 != no flag yet (see encode_tfaceflag) */
+       flag -= 1;
+
+       alphablend = flag >> 15; //encoded in the encode_tfaceflag function
+       (*game).flag = 0;
+       
+       /* General Material Options */
+       if ((flag & TF_DYNAMIC)==0) (*game).flag        |= GEMAT_NOPHYSICS;
+       
+       /* Material Offline Rendering Properties */
+       if (convertall) {
+               if (flag & TF_OBCOL) ma->shade_flag |= MA_OBCOLOR;
+       }
+       
+       /* Special Face Properties */
+       if ((flag & TF_TWOSIDE)==0) (*game).flag |= GEMAT_BACKCULL;
+       if (flag & TF_INVISIBLE)(*game).flag |= GEMAT_INVISIBLE;
+       if (flag & TF_BMFONT) (*game).flag |= GEMAT_TEXT;
+       
+       /* Face Orientation */
+       if (flag & TF_BILLBOARD) (*game).face_orientation |= GEMAT_HALO;
+       else if (flag & TF_BILLBOARD2) (*game).face_orientation |= GEMAT_BILLBOARD;
+       else if (flag & TF_SHADOW) (*game).face_orientation |= GEMAT_SHADOW;
+       
+       /* Alpha Blend */
+       if (flag & TF_ALPHASORT && ELEM(alphablend, TF_ALPHA, TF_ADD)) (*game).alpha_blend = GEMAT_ALPHA_SORT;
+       else if (alphablend & TF_ALPHA) (*game).alpha_blend = GEMAT_ALPHA;
+       else if (alphablend & TF_ADD) (*game).alpha_blend = GEMAT_ADD;
+       else if (alphablend & TF_CLIP) (*game).alpha_blend = GEMAT_CLIP;
+}
+
+/* boolean check to see if the mesh needs a material */
+int check_tfaceneedmaterial(int flag)
+{
+       // check if the flags we have are not deprecated != than default material options
+       // also if only flags are visible and collision see if all objects using this mesh have this option in physics
+
+       /* flag is shifted in 1 to make 0 != no flag yet (see encode_tfaceflag) */
+       flag -=1;
+
+       // deprecated flags
+       flag &= ~TF_OBCOL;
+       flag &= ~TF_SHAREDVERT;
+       flag &= ~TF_SHAREDCOL;
+
+       /* light tface flag is ignored in GLSL mode */
+       flag &= ~TF_LIGHT;
+       
+       // automatic detected if tex image has alpha
+       flag &= ~(TF_ALPHA << 15);
+       // automatic detected if using texture
+       flag &= ~TF_TEX;
+
+       // settings for the default NoMaterial
+       if (flag == TF_DYNAMIC)
+               return 0;
+
+       else
+               return 1;
+}
+
+/* return number of digits of an integer */
+// XXX to be optmized or replaced by an equivalent blender internal function
+int integer_getdigits(int number)
+{
+       int i=0;
+       if (number == 0) return 1;
+
+       while (number != 0){
+               number = (int)(number/10);
+               i++;
+       }
+       return i;
+}
+
+void calculate_tface_materialname(char *matname, char *newname, int flag)
+{
+       // if flag has only light and collision and material matches those values
+       // you can do strcpy(name, mat_name);
+       // otherwise do:
+       int digits = integer_getdigits(flag);
+       /* clamp the old name, remove the MA prefix and add the .TF.flag suffix
+       e.g. matname = "MALoooooooooooooongName"; newname = "Loooooooooooooon.TF.2" */
+       sprintf(newname, "%.*s.TF.%0*d", MAX_ID_NAME-(digits+5), matname, digits, flag);
+}
+
+/* returns -1 if no match */
+int mesh_getmaterialnumber(Mesh *me, Material *ma) {
+       int a;
+
+       for (a=0; a<me->totcol; a++)
+               if (me->mat[a] == ma)
+                       return a;
+
+       return -1;
+}
+
+/* append material */
+int mesh_addmaterial(Mesh *me, Material *ma)
+{
+       material_append_id(&me->id, NULL);
+       me->mat[me->totcol-1]= ma;
+
+       id_us_plus(&ma->id);
+
+       return me->totcol-1;
+}
+
+Material *materialbyname(Main *main, char *name)
+{
+       Material *mat = NULL;
+       for (mat=main->mat.first;mat;mat=mat->id.next) {
+               if (strcmp(mat->id.name, name)==0)
+                       return mat; 
+       }
+       return NULL;
+}
+
+void set_facetexture_flags(Material *ma, Image *image)
+{
+       if(image) {
+               ma->mode |= MA_FACETEXTURE;
+               /* we could check if the texture has alpha, but then more meshes sharing the same
+                * material may need it. Let's make it simple. */
+               if(BKE_image_has_alpha(image))
+                       ma->mode |= MA_FACETEXTURE_ALPHA;
+       }
+}
+
+/* returns material number */
+int convert_tfacenomaterial(Main *main, Mesh *me, MTFace *tf, int flag)
+{
+       Material *ma;
+       char name[MAX_ID_NAME];
+       int mat_nr= -1;
+       
+       /* new material, the name uses the flag*/
+       sprintf(name, "MAMaterial.TF.%0*d", integer_getdigits(flag), flag);
+       
+       if ((ma=materialbyname(main, name))) {
+               mat_nr = mesh_getmaterialnumber(me, ma);
+               /* assign the material to the mesh */
+               if(mat_nr == -1) mat_nr= mesh_addmaterial(me, ma);
+
+               /* if needed set "Face Textures [Alpha]" Material options */
+               set_facetexture_flags(ma, tf->tpage);
+       }
+       /* create a new material */
+       else {
+               ma=add_material(name+2);
+
+               if(ma){
+                       printf("TexFace Convert: Material \"%s\" created.\n", name+2);
+                       mat_nr= mesh_addmaterial(me, ma);
+                       
+                       /* if needed set "Face Textures [Alpha]" Material options */
+                       set_facetexture_flags(ma, tf->tpage);
+
+                       decode_tfaceflag(ma, flag, 1);
+                       // the final decoding will happen after, outside the main loop
+                       // for now store the flag into the material and change light/tex/collision 
+                       // store the flag as a negative number
+                       ma->game.flag = -flag;
+                       id_us_min((ID *)ma);    
+               }
+               else printf("Error: Unable to create Material \"%s\" for Mesh \"%s\".", name+2, me->id.name+2);
+       }
+
+       /* set as converted, no need to go bad to this face */
+       tf->mode |= TF_CONVERTED;       
+       return mat_nr;
+}
+
+/* Function to fully convert materials */
+void convert_tfacematerial(Main *main, Material *ma)
+{
+       Mesh *me;
+       Material *mat_new;
+       MFace *mf;
+       MTFace *tf;
+       int flag, index;
+       int a, mat_nr;
+       CustomDataLayer *cdl;
+       char name[MAX_ID_NAME];
+
+       for(me=main->mesh.first; me; me=me->id.next){
+               /* check if this mesh uses this material */
+               for(a=0;a<me->totcol;a++)
+                       if(me->mat[a] == ma) break;
+                       
+               /* no material found */
+               if (a == me->totcol) continue;
+
+               /* get the active tface layer */
+               index= CustomData_get_active_layer_index(&me->fdata, CD_MTFACE);
+               cdl= (index == -1)? NULL: &me->fdata.layers[index];
+               if (!cdl) continue;
+
+               /* loop over all the faces and stop at the ones that use the material*/
+               for(a=0, mf=me->mface; a<me->totface; a++, mf++) {
+                       if(me->mat[(int)mf->mat_nr] != ma) continue;
+
+                       /* texface data for this face */
+                       tf = ((MTFace*)cdl->data) + a;
+                       flag = encode_tfaceflag(tf, 1);
+
+                       /* the name of the new material */
+                       calculate_tface_materialname(ma->id.name, (char *)&name, flag);
+
+                       if ((mat_new=materialbyname(main, name))) {
+                               /* material already existent, see if the mesh has it */
+                               mat_nr = mesh_getmaterialnumber(me, mat_new);
+                               /* material is not in the mesh, add it */
+                               if(mat_nr == -1) mat_nr= mesh_addmaterial(me, mat_new);
+                       }
+                       /* create a new material */
+                       else {
+                               mat_new=copy_material(ma);
+                               if(mat_new){
+                                       /* rename the material*/
+                                       strcpy(mat_new->id.name, name);
+                                       id_us_min((ID *)mat_new);       
+
+                                       mat_nr= mesh_addmaterial(me, mat_new);
+                                       decode_tfaceflag(mat_new, flag, 1);
+                               }
+                               else {
+                                       printf("Error: Unable to create Material \"%s\" for Mesh \"%s.", name+2, me->id.name+2);
+                                       mat_nr = mf->mat_nr;
+                                       continue;
+                               }
+                       }
+                       
+                       /* if the material has a texture but no texture channel
+                        * set "Face Textures [Alpha]" Material options 
+                        * actually we need to run it always, because of old behavior
+                        * of using face texture if any texture channel was present (multitex) */
+                       //if((!mat_new->mtex[0]) && (!mat_new->mtex[0]->tex))
+                       set_facetexture_flags(mat_new, tf->tpage);
+
+                       /* set the material number to the face*/
+                       mf->mat_nr = mat_nr;
+               }
+               /* remove material from mesh */
+               for(a=0;a<me->totcol;)
+                       if(me->mat[a] == ma) material_pop_id(&me->id, a, 1);else a++;
+       }
+}
+
+int do_version_tface(Main *main, int fileload)
+{
+       Mesh *me;
+       Material *ma;
+       MFace *mf;
+       MTFace *tf;
+       CustomDataLayer *cdl;
+       int a;
+       int flag;
+       int index;
+       int nummat;
+
+       /* sometimes mesh has no materials but will need a new one. In those
+        * cases we need to ignore the mf->mat_nr and only look at the face
+        * mode because it can be zero as unitialized or the 1st created material
+        */
+       int nomaterialslots;
+
+       /* alert to user to check the console */
+       int nowarning = 1;
+
+       /* mark all the materials to convertion with a flag
+        * if there is tface create a complete flag for that storing in flag
+        * if there is tface and flag > 0: creates a new flag based on this face
+        * if flags are different set flag to -1  
+        */
+       
+       /* 1st part: marking mesh materials to update */
+       for(me=main->mesh.first; me; me=me->id.next){
+               if (me->id.lib) continue;
+
+               /* get the active tface layer */
+               index= CustomData_get_active_layer_index(&me->fdata, CD_MTFACE);
+               cdl= (index == -1)? NULL: &me->fdata.layers[index];
+               if (!cdl) continue;
+
+               nomaterialslots = (me->totcol==0?1:0);
+               
+               /* loop over all the faces*/
+               for(a=0, mf=me->mface; a<me->totface; a++, mf++) {
+                       /* texface data for this face */
+                       tf = ((MTFace*)cdl->data) + a;
+
+                       /* conversion should happen only once */
+                       if (fileload)
+                               tf->mode &= ~TF_CONVERTED;
+                       else {
+                               if((tf->mode & TF_CONVERTED)) continue;
+                               else tf->mode |= TF_CONVERTED;
+                       }
+                       
+                       /* no material slots */
+                       if(nomaterialslots) {
+                               flag = encode_tfaceflag(tf, 1);
+                               
+                               /* create/find a new material and assign to the face */
+                               if (check_tfaceneedmaterial(flag))
+                                       mf->mat_nr= convert_tfacenomaterial(main, me, tf, flag);
+                                       
+                       /* else mark them as no-material to be reverted to 0 later */
+                               else
+                                       mf->mat_nr = -1;
+                       }
+                       else if(mf->mat_nr < me->totcol) {
+                               ma= me->mat[(int)mf->mat_nr];
+                               
+                               /* no material create one if necessary */
+                               if(!ma) {
+                                       /* find a new material and assign to the face */
+                                       flag = encode_tfaceflag(tf, 1);
+
+                                       /* create/find a new material and assign to the face */
+                                       if (check_tfaceneedmaterial(flag))
+                                               mf->mat_nr= convert_tfacenomaterial(main, me, tf, flag);
+
+                                       continue;
+                               }
+
+                               /* we can't read from this if it comes from a library,
+                                * at doversion time: direct_link might not have happened on it,
+                                * so ma->mtex is not pointing to valid memory yet.
+                                * later we could, but it's better not */
+                               else if(ma->id.lib)
+                                       continue;
+                               
+                               /* material already marked as disputed */
+                               else if(ma->game.flag == -99999)
+                                       continue;
+
+                               /* found a material */
+                               else {
+                                       flag = encode_tfaceflag(tf, ((fileload)?0:1));
+
+                                       /* first time changing this material */
+                                       if (ma->game.flag == 0)
+                                               ma->game.flag= -flag;
+                       
+                                       /* mark material as disputed */
+                                       else if (ma->game.flag != -flag) {
+                                               ma->game.flag = -99999;
+                                               continue;
+                                       }
+                       
+                                       /* material ok so far */
+                                       else {
+                                               ma->game.flag = -flag;
+                                               
+                                               /* some people uses multitexture with TexFace by creating a texture
+                                                * channel which not necessarly the tf->tpage image. But the game engine
+                                                * was enabling it. Now it's required to set "Face Texture [Alpha] in the
+                                                * material settings. */
+                                               if(!fileload)
+                                                       set_facetexture_flags(ma, tf->tpage);
+                                       }
+                               }
+                       }
+                       else
+                               continue;
+               }
+
+               /* if we didn't have material slot and now we do, we need to
+                * make sure the materials are correct */
+               if(nomaterialslots) {
+                       if (me->totcol>0) {
+                               for(a=0, mf=me->mface; a<me->totface; a++, mf++) {
+                                       if (mf->mat_nr == -1) {
+                                               /* texface data for this face */
+                                               tf = ((MTFace*)cdl->data) + a;
+                                               mf->mat_nr= convert_tfacenomaterial(main, me, tf, encode_tfaceflag(tf, 1));
+                                       }
+                               }
+                       } else {
+                               for(a=0, mf=me->mface; a<me->totface; a++, mf++)
+                                       mf->mat_nr=0;
+                       }
+               }
+
+       }
+       
+       /* 2nd part - conversion */
+       /* skip library files */
+
+       /* we shouldn't loop through the materials created in the loop. make the loop stop at its original length) */
+       for (ma= main->mat.first, a=0; ma; ma= ma->id.next, a++) {
+               if (ma->id.lib) continue;
+
+               /* disputed material */
+               if (ma->game.flag == -99999) {
+                       ma->game.flag = 0;
+                       if (fileload) {
+                               printf("Warning: material \"%s\" skipped - to convert old game texface to material go to the Help menu.\n", ma->id.name+2);
+                               nowarning = 0;
+                       }
+                       else
+                               convert_tfacematerial(main, ma);
+                       continue;       
+               }
+       
+               /* no conflicts in this material - 90% of cases
+                * convert from tface system to material */
+               else if (ma->game.flag < 0){
+                       decode_tfaceflag(ma, -(ma->game.flag), 1);
+
+                       /* material is good make sure all faces using
+                        * this material are set to converted */
+                       if (fileload) {
+                               for(me=main->mesh.first; me; me=me->id.next){
+                                       /* check if this mesh uses this material */
+                                       for(a=0;a<me->totcol;a++)
+                                               if(me->mat[a] == ma) break;
+                                               
+                                       /* no material found */
+                                       if (a == me->totcol) continue;
+                       
+                                       /* get the active tface layer */
+                                       index= CustomData_get_active_layer_index(&me->fdata, CD_MTFACE);
+                                       cdl= (index == -1)? NULL: &me->fdata.layers[index];
+                                       if (!cdl) continue;
+                       
+                                       /* loop over all the faces and stop at the ones that use the material*/
+                                       for(a=0, mf=me->mface; a<me->totface; a++, mf++) {
+                                               if(me->mat[(int)mf->mat_nr] != ma) continue;
+                                               else tf->mode |= TF_CONVERTED;
+                                       }
+                               }
+                       }
+               }
+       }
+
+       return nowarning;
+}
+
index 2ff555b5b22bc009cb064de5b872bda80d8e6017..44242507616c0c175f4a242880c0551d31fd32af 100644 (file)
@@ -1378,7 +1378,6 @@ static void ccgDM_drawMappedFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, v
        int gridSize = ccgSubSurf_getGridSize(ss);
        int gridFaces = gridSize - 1;
        int edgeSize = ccgSubSurf_getEdgeSize(ss);
-       int transp, orig_transp, new_transp;
        char *faceFlags = ccgdm->faceFlags;
        int a, b, i, doDraw, numVerts, matnr, new_matnr, totface;
 
@@ -1386,8 +1385,6 @@ static void ccgDM_drawMappedFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, v
 
        doDraw = 0;
        matnr = -1;
-       transp = GPU_get_material_blend_mode();
-       orig_transp = transp;
 
 #define PASSATTRIB(dx, dy, vert) {                                                                                             \
        if(attribs.totorco) {                                                                                                           \
@@ -1439,18 +1436,6 @@ static void ccgDM_drawMappedFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, v
                        continue;
                }
 
-               if(tf) {
-                       new_transp = tf[i].transp;
-
-                       if(new_transp != transp) {
-                               if(new_transp == GPU_BLEND_SOLID && orig_transp != GPU_BLEND_SOLID)
-                                       GPU_set_material_blend_mode(orig_transp);
-                               else
-                                       GPU_set_material_blend_mode(new_transp);
-                               transp = new_transp;
-                       }
-               }
-
                glShadeModel(drawSmooth? GL_SMOOTH: GL_FLAT);
                for (S=0; S<numVerts; S++) {
                        DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
index 38454547f483d5ca6b8c1e0fb86c695ed59a5f20..a5484d218d2374a848e97561730dd1d904983177 100644 (file)
@@ -238,6 +238,7 @@ typedef struct OldNewMap {
 /* local prototypes */
 static void *read_struct(FileData *fd, BHead *bh, const char *blockname);
 static void direct_link_modifiers(FileData *fd, ListBase *lb);
+static void convert_tface_mt(FileData *fd, Main *main);
 
 static OldNewMap *oldnewmap_new(void) 
 {
@@ -3478,6 +3479,9 @@ static void lib_link_mesh(FileData *fd, Main *main)
                }
                me= me->id.next;
        }
+
+       /* convert texface options to material */
+       convert_tface_mt(fd, main);
 }
 
 static void direct_link_dverts(FileData *fd, int count, MDeformVert *mdverts)
@@ -7038,6 +7042,27 @@ static void do_versions_nodetree_dynamic_sockets(bNodeTree *ntree)
                sock->flag |= SOCK_DYNAMIC;
 }
 
+void convert_tface_mt(FileData *fd, Main *main)
+{
+       Main *gmain;
+
+       /* this is a delayed do_version (so it can create new materials) */
+       if (main->versionfile < 259 || (main->versionfile == 259 && main->subversionfile < 3)) {
+
+               //XXX hack, material.c uses G.main all over the place, instead of main
+               // temporarily set G.main to the current main
+               gmain = G.main;
+               G.main = main;
+
+               if(!(do_version_tface(main, 1))) {
+                       BKE_report(fd->reports, RPT_ERROR, "Texface conversion problem. Error in console");
+               }
+
+               //XXX hack, material.c uses G.main allover the place, instead of main
+               G.main = gmain;
+       }
+}
+
 static void do_versions(FileData *fd, Library *lib, Main *main)
 {
        /* WATCH IT!!!: pointers from libdata have not been converted */
index b256eeac4bcb1bd6a82c137d7a9ff8309d003c84..8c035ca46fdd3ed6a3ddf61c882fddb24466942b 100644 (file)
@@ -1473,10 +1473,8 @@ static void EM_mesh_copy_face(EditMesh *em, wmOperator *op, short type)
                                tf = CustomData_em_get(&em->fdata, efa->data, CD_MTFACE);
                                if (tf_act->tpage) {
                                        tf->tpage = tf_act->tpage;
-                                       tf->mode |= TF_TEX;
                                } else {
                                        tf->tpage = NULL;
-                                       tf->mode &= ~TF_TEX;
                                }
                                tf->tile= tf_act->tile;
                                change = 1;
@@ -1656,10 +1654,8 @@ void EM_mesh_copy_face_layer(EditMesh *em, wmOperator *op, short type)
                                tf = CustomData_em_get(&em->fdata, efa->data, CD_MTFACE);
                                if (tf_from->tpage) {
                                        tf->tpage = tf_from->tpage;
-                                       tf->mode |= TF_TEX;
                                } else {
                                        tf->tpage = NULL;
-                                       tf->mode &= ~TF_TEX;
                                }
                                tf->tile= tf_from->tile;
                                change = 1;
index afab4ede229b54e3935573069ce432815f577fc5..e345caf1359e73ca38d427af59f6eb08070e3bd2 100644 (file)
@@ -595,7 +595,7 @@ static void image_refresh(const bContext *C, ScrArea *UNUSED(sa))
                        
                        tf = EM_get_active_mtface(em, NULL, NULL, 1); /* partially selected face is ok */
                        
-                       if(tf && (tf->mode & TF_TEX)) {
+                       if(tf) {
                                /* don't need to check for pin here, see above */
                                sima->image= tf->tpage;
                                
index 60e9595b77a0faad969b69d5d7eb5d33369406b0..b7f9af093488fec67244effaec7daeaf91c3bc1d 100644 (file)
@@ -43,6 +43,7 @@
 #include "BKE_context.h"
 #include "BKE_main.h"
 #include "BKE_sca.h"
+#include "BKE_material.h" //for texface convert
 
 #include "ED_logic.h"
 #include "ED_object.h"
 
 #include "logic_intern.h"
 
+// temporary new includes for texface functions
+#include "DNA_mesh_types.h"
+#include "DNA_material_types.h"
+#include "DNA_meshdata_types.h"
+
 /* ************* Generic Operator Helpers ************* */
 static int edit_sensor_poll(bContext *C)
 {
@@ -687,6 +693,36 @@ static void LOGIC_OT_actuator_move(wmOperatorType *ot)
        RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
 }
 
+/* ************* TexFace Converter Operator ************* */
+static int texface_convert_exec(bContext *C, wmOperator *UNUSED(op))
+{
+       Main *bmain= CTX_data_main(C);
+       do_version_tface(bmain, 0);
+       
+       return OPERATOR_FINISHED;
+}
+
+static int texface_convert_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
+{
+       return texface_convert_exec(C, op);
+}
+
+ static void LOGIC_OT_texface_convert(wmOperatorType *ot)
+{
+       /* identifiers */
+       ot->name= "TexFace to Material Converter";
+       ot->description = "Convert old texface settings into material. It may create new materials if needed";
+       ot->idname= "LOGIC_OT_texface_convert";
+
+       /* api callbacks */
+       ot->invoke= texface_convert_invoke;
+       ot->exec= texface_convert_exec;
+//     ot->poll= texface_convert_poll;
+       /* flags */
+       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+}
+
 
 void ED_operatortypes_logic(void)
 {
@@ -699,4 +735,5 @@ void ED_operatortypes_logic(void)
        WM_operatortype_append(LOGIC_OT_actuator_remove);
        WM_operatortype_append(LOGIC_OT_actuator_add);
        WM_operatortype_append(LOGIC_OT_actuator_move);
+       WM_operatortype_append(LOGIC_OT_texface_convert);
 }
index b8d33de2e372877f49c8a5c6a0003c511dbd2b4c..42ee6c0f00a9fba70deb260b445d6ed8aec13c35 100644 (file)
@@ -64,6 +64,7 @@
 #include "GPU_buffers.h"
 #include "GPU_extensions.h"
 #include "GPU_draw.h"
+#include "GPU_material.h"
 
 #include "ED_mesh.h"
 
@@ -207,44 +208,71 @@ static Material *give_current_material_or_def(Object *ob, int matnr)
        return ma?ma:&defmaterial;
 }
 
-static int set_draw_settings_cached(int clearcache, int textured, MTFace *texface, int lit, Object *litob, int litmatnr, int doublesided)
+/* Icky globals, fix with userdata parameter */
+
+static struct TextureDrawState {
+       Object *ob;
+       int islit, istex;
+       int color_profile;
+       unsigned char obcol[4];
+} Gtexdraw = {NULL, 0, 0, 0, {0, 0, 0, 0}};
+
+static int set_draw_settings_cached(int clearcache, MTFace *texface, Material *ma, struct TextureDrawState gtexdraw)
 {
+       static Material *c_ma;
        static int c_textured;
-       static int c_lit;
-       static int c_doublesided;
        static MTFace *c_texface;
-       static Object *c_litob;
-       static int c_litmatnr;
+       static int c_backculled;
        static int c_badtex;
+       static int c_lit;
 
+       Object *litob = NULL; //to get mode to turn off mipmap in painting mode
+       int backculled = 0;
+       int alphablend = 0;
+       int textured = 0;
+       int lit = 0;
+       
        if (clearcache) {
-               c_textured= c_lit= c_doublesided= -1;
+               c_textured= c_lit= c_backculled= -1;
                c_texface= (MTFace*) -1;
-               c_litob= (Object*) -1;
-               c_litmatnr= -1;
                c_badtex= 0;
+       } else {
+               textured = gtexdraw.istex;
+               litob = gtexdraw.ob;
+       }
+
+       /* convert number of lights into boolean */
+       if (gtexdraw.islit) lit = 1;
+
+       if (ma) {
+               alphablend = ma->game.alpha_blend;
+               if (ma->mode & MA_SHLESS) lit = 0;
+               backculled = ma->game.flag & GEMAT_BACKCULL;
        }
 
        if (texface) {
-               lit = lit && (lit==-1 || texface->mode&TF_LIGHT);
-               textured = textured && (texface->mode&TF_TEX);
-               doublesided = texface->mode&TF_TWOSIDE;
-       } else {
-               textured = 0;
+               textured = textured && (texface->tpage);
+
+               /* no material, render alpha if texture has depth=32 */
+               if (!ma && BKE_image_has_alpha(texface->tpage))
+                       alphablend = GPU_BLEND_ALPHA;
        }
 
-       if (doublesided!=c_doublesided) {
-               if (doublesided) glDisable(GL_CULL_FACE);
-               else glEnable(GL_CULL_FACE);
+       else
+               textured = 0;
+
+       if (backculled!=c_backculled) {
+               if (backculled) glEnable(GL_CULL_FACE);
+               else glDisable(GL_CULL_FACE);
 
-               c_doublesided= doublesided;
+               c_backculled= backculled;
        }
 
        if (textured!=c_textured || texface!=c_texface) {
                if (textured ) {
-                       c_badtex= !GPU_set_tpage(texface, !(litob->mode & OB_MODE_TEXTURE_PAINT));
+                       c_badtex= !GPU_set_tpage(texface, !(litob->mode & OB_MODE_TEXTURE_PAINT), alphablend);
                } else {
-                       GPU_set_tpage(NULL, 0);
+                       GPU_set_tpage(NULL, 0, 0);
                        c_badtex= 0;
                }
                c_textured= textured;
@@ -252,10 +280,10 @@ static int set_draw_settings_cached(int clearcache, int textured, MTFace *texfac
        }
 
        if (c_badtex) lit= 0;
-       if (lit!=c_lit || litob!=c_litob || litmatnr!=c_litmatnr) {
+       if (lit!=c_lit || ma!=c_ma) {
                if (lit) {
-                       Material *ma= give_current_material_or_def(litob, litmatnr+1);
                        float spec[4];
+                       if (!ma)ma= give_current_material_or_def(NULL, 0); //default material
 
                        spec[0]= ma->spec*ma->specr;
                        spec[1]= ma->spec*ma->specg;
@@ -273,22 +301,11 @@ static int set_draw_settings_cached(int clearcache, int textured, MTFace *texfac
                        glDisable(GL_COLOR_MATERIAL);
                }
                c_lit= lit;
-               c_litob= litob;
-               c_litmatnr= litmatnr;
        }
 
        return c_badtex;
 }
 
-/* Icky globals, fix with userdata parameter */
-
-static struct TextureDrawState {
-       Object *ob;
-       int islit, istex;
-       int color_profile;
-       unsigned char obcol[4];
-} Gtexdraw = {NULL, 0, 0, 0, {0, 0, 0, 0}};
-
 static void draw_textured_begin(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob)
 {
        unsigned char obcol[4];
@@ -318,14 +335,14 @@ static void draw_textured_begin(Scene *scene, View3D *v3d, RegionView3D *rv3d, O
        Gtexdraw.istex = istex;
        Gtexdraw.color_profile = scene->r.color_mgt_flag & R_COLOR_MANAGEMENT;
        memcpy(Gtexdraw.obcol, obcol, sizeof(obcol));
-       set_draw_settings_cached(1, 0, NULL, Gtexdraw.islit, NULL, 0, 0);
+       set_draw_settings_cached(1, NULL, NULL, Gtexdraw);
        glShadeModel(GL_SMOOTH);
 }
 
 static void draw_textured_end(void)
 {
        /* switch off textures */
-       GPU_set_tpage(NULL, 0);
+       GPU_set_tpage(NULL, 0, 0);
 
        glShadeModel(GL_FLAT);
        glDisable(GL_CULL_FACE);
@@ -347,18 +364,22 @@ static void draw_textured_end(void)
 
 static int draw_tface__set_draw_legacy(MTFace *tface, MCol *mcol, int matnr)
 {
-       if (tface && (tface->mode&TF_INVISIBLE)) return 0;
+       Material *ma= give_current_material(Gtexdraw.ob, matnr+1);
+       int validtexture=0;
+
+       if (ma && (ma->game.flag & GEMAT_INVISIBLE)) return 0;
 
-       if (tface && set_draw_settings_cached(0, Gtexdraw.istex, tface, Gtexdraw.islit, Gtexdraw.ob, matnr, TF_TWOSIDE)) {
+       validtexture = set_draw_settings_cached(0, tface, ma, Gtexdraw);
+
+       if (tface && validtexture) {
                glColor3ub(0xFF, 0x00, 0xFF);
                return 2; /* Don't set color */
-       } else if (tface && tface->mode&TF_OBCOL) {
+       } else if (ma && ma->shade_flag&MA_OBCOLOR) {
                glColor3ubv(Gtexdraw.obcol);
                return 2; /* Don't set color */
        } else if (!mcol) {
                if (tface) glColor3f(1.0, 1.0, 1.0);
                else {
-                       Material *ma= give_current_material(Gtexdraw.ob, matnr+1);
                        if(ma) {
                                float col[3];
                                if(Gtexdraw.color_profile) linearrgb_to_srgb_v3_v3(col, &ma->r);
@@ -375,9 +396,11 @@ static int draw_tface__set_draw_legacy(MTFace *tface, MCol *mcol, int matnr)
 }
 static int draw_tface__set_draw(MTFace *tface, MCol *mcol, int matnr)
 {
-       if (tface && (tface->mode&TF_INVISIBLE)) return 0;
+       Material *ma= give_current_material(Gtexdraw.ob, matnr+1);
 
-       if (tface && set_draw_settings_cached(0, Gtexdraw.istex, tface, Gtexdraw.islit, Gtexdraw.ob, matnr, TF_TWOSIDE)) {
+       if (ma && (ma->game.flag & GEMAT_INVISIBLE)) return 0;
+
+       if (tface && set_draw_settings_cached(0, tface, ma, Gtexdraw)) {
                return 2; /* Don't set color */
        } else if (tface && tface->mode&TF_OBCOL) {
                return 2; /* Don't set color */
@@ -399,7 +422,9 @@ static void add_tface_color_layer(DerivedMesh *dm)
 
        finalCol = MEM_mallocN(sizeof(MCol)*4*dm->getNumFaces(dm),"add_tface_color_layer");
        for(i=0;i<dm->getNumFaces(dm);i++) {
-               if (tface && (tface->mode&TF_INVISIBLE)) {
+               Material *ma= give_current_material(Gtexdraw.ob, mface[i].mat_nr+1);
+
+               if (ma && (ma->game.flag&GEMAT_INVISIBLE)) {
                        if( mcol )
                                memcpy(&finalCol[i*4],&mcol[i*4],sizeof(MCol)*4);
                        else
@@ -409,7 +434,7 @@ static void add_tface_color_layer(DerivedMesh *dm)
                                        finalCol[i*4+j].r = 255;
                                }
                }
-               else if (tface && mface && set_draw_settings_cached(0, Gtexdraw.istex, tface, Gtexdraw.islit, Gtexdraw.ob, mface[i].mat_nr, TF_TWOSIDE)) {
+               else if (tface && mface && set_draw_settings_cached(0, tface, ma, Gtexdraw)) {
                        for(j=0;j<4;j++) {
                                finalCol[i*4+j].b = 255;
                                finalCol[i*4+j].g = 0;
@@ -493,10 +518,14 @@ static int draw_em_tf_mapped__set_draw(void *userData, int index)
 static int wpaint__setSolidDrawOptions(void *userData, int index, int *drawSmooth_r)
 {
        Mesh *me = (Mesh*)userData;
+       Material *ma;
+
+       if (me->mface) {
+               int matnr = me->mface[index].mat_nr;
+               ma = me->mat[matnr];
+       }
 
-       if (    (me->mface && me->mface[index].flag & ME_HIDE) ||
-                       (me->mtface && (me->mtface[index].mode & TF_INVISIBLE))
-       ) {
+       if ( ma && (ma->game.flag & GEMAT_INVISIBLE)) {
                return 0;
        }
 
@@ -529,11 +558,12 @@ static void draw_mesh_text(Scene *scene, Object *ob, int glsl)
        ddm = mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH);
 
        for(a=0, mf=mface; a<totface; a++, tface++, mf++) {
-               int mode= tface->mode;
                int matnr= mf->mat_nr;
                int mf_smooth= mf->flag & ME_SMOOTH;
+               Material *mat = me->mat[matnr];
+               int mode= mat->game.flag;
 
-               if (!(mf->flag&ME_HIDE) && !(mode&TF_INVISIBLE) && (mode&TF_BMFONT)) {
+               if (!(mode&GEMAT_INVISIBLE) && (mode&GEMAT_TEXT)) {
                        float v1[3], v2[3], v3[3], v4[3];
                        char string[MAX_PROPSTRING];
                        int characters, i, glattrib= -1, badtex= 0;
@@ -549,7 +579,7 @@ static void draw_mesh_text(Scene *scene, Object *ob, int glsl)
                                }
                        }
                        else {
-                               badtex = set_draw_settings_cached(0, Gtexdraw.istex, tface, Gtexdraw.islit, Gtexdraw.ob, matnr, TF_TWOSIDE);
+                               badtex = set_draw_settings_cached(0, tface, mat, Gtexdraw);
                                if (badtex) {
                                        if (mcol) mcol+=4;
                                        continue;
@@ -578,7 +608,7 @@ static void draw_mesh_text(Scene *scene, Object *ob, int glsl)
                                glNormal3fv(nor);
                        }
 
-                       GPU_render_text(tface, tface->mode, string, characters,
+                       GPU_render_text(tface, mode, string, characters,
                                (unsigned int*)mcol, v1, v2, v3, (mf->v4? v4: NULL), glattrib);
                }
                if (mcol) {
index ecdac083aed15d19408e0753e556f3ec0bc9d32a..e738d5abe69f362b34486625d017a1550e08cb6d 100644 (file)
@@ -220,16 +220,13 @@ int draw_glsl_material(Scene *scene, Object *ob, View3D *v3d, int dt)
        return (scene->gm.matmode == GAME_MAT_GLSL) && (dt > OB_SOLID);
 }
 
-static int check_material_alpha(Base *base, Mesh *me, int glsl)
+static int check_material_alpha(Base *base, int glsl)
 {
        if(base->flag & OB_FROMDUPLI)
                return 0;
 
        if(G.f & G_PICKSEL)
                return 0;
-                       
-       if(me->edit_mesh)
-               return 0;
        
        return (glsl || (base->object->dtx & OB_DRAWTRANSP));
 }
@@ -2998,12 +2995,16 @@ static int draw_mesh_object(Scene *scene, ARegion *ar, View3D *v3d, RegionView3D
                                                                                        scene->customdata_mask);
 
                if(dt>OB_WIRE) {
-                       // no transp in editmode, the fancy draw over goes bad then
                        glsl = draw_glsl_material(scene, ob, v3d, dt);
-                       GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl, NULL);
+                       check_alpha = check_material_alpha(base, glsl);
+
+                       GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl,
+                                       (check_alpha)? &do_alpha_pass: NULL);
                }
 
-               draw_em_fancy(scene, v3d, rv3d, ob, em, cageDM, finalDM, dt);
+               // transp in editmode makes the fancy draw over go bad
+               if (!do_alpha_pass)
+                       draw_em_fancy(scene, v3d, rv3d, ob, em, cageDM, finalDM, dt);
 
                GPU_end_object_materials();
 
@@ -3014,7 +3015,7 @@ static int draw_mesh_object(Scene *scene, ARegion *ar, View3D *v3d, RegionView3D
                /* don't create boundbox here with mesh_get_bb(), the derived system will make it, puts deformed bb's OK */
                if(me->totface<=4 || ED_view3d_boundbox_clip(rv3d, ob->obmat, (ob->bb)? ob->bb: me->bb)) {
                        glsl = draw_glsl_material(scene, ob, v3d, dt);
-                       check_alpha = check_material_alpha(base, me, glsl);
+                       check_alpha = check_material_alpha(base, glsl);
 
                        if(dt==OB_SOLID || glsl) {
                                GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl,
index 45d832d4739404d5c8442758e0e2ca146d5295f0..8227ba87021521bb2b7630cc51f3b0a7adad2630 100644 (file)
@@ -1667,7 +1667,7 @@ static void RestoreState(bContext *C, wmWindow *win)
                win->queue= queue_back;
        
        GPU_state_init();
-       GPU_set_tpage(NULL, 0);
+       GPU_set_tpage(NULL, 0, 0);
 
        glPopAttrib();
 }
index 9a21305457c57a96c8c01ef6fb6e192757c30807..cd1c5594822d7887c6dd1987d238e63a4bd6d535 100644 (file)
@@ -125,14 +125,12 @@ void ED_uvedit_assign_image(Scene *scene, Object *obedit, Image *ima, Image *pre
                if(uvedit_face_visible(scene, previma, efa, tf)) {
                        if(ima) {
                                tf->tpage= ima;
-                               tf->mode |= TF_TEX;
                                
                                if(ima->id.us==0) id_us_plus(&ima->id);
                                else id_lib_extern(&ima->id);
                        }
                        else {
                                tf->tpage= NULL;
-                               tf->mode &= ~TF_TEX;
                        }
 
                        update = 1;
index d75b8db2c4e2f7dc65d0bfd7af6a5108844a4c39..55c4ff85a57bda02262ed1a47ce56e816f57e90b 100644 (file)
@@ -80,15 +80,15 @@ void GPU_end_object_materials(void);
 int GPU_enable_material(int nr, void *attribs);
 void GPU_disable_material(void);
 
-void GPU_set_material_blend_mode(int blendmode);
-int GPU_get_material_blend_mode(void);
+void GPU_set_material_alpha_blend(int alphablend);
+int GPU_get_material_alpha_blend(void);
 
 /* TexFace drawing
  * - this is mutually exclusive with material drawing, a mesh should
  *   be drawn using one or the other
  * - passing NULL clears the state again */
 
-int GPU_set_tpage(struct MTFace *tface, int mipmap);
+int GPU_set_tpage(struct MTFace *tface, int mipmap, int transp);
 
 /* Lights
  * - returns how many lights were enabled
index 95a08e6d5b30a8db7b7ff980738c7097240f9a33..29ad9c9137406a012e7a63ec51700ca71aeda26b 100644 (file)
@@ -94,7 +94,8 @@ typedef enum GPUBlendMode {
        GPU_BLEND_SOLID = 0,
        GPU_BLEND_ADD = 1,
        GPU_BLEND_ALPHA = 2,
-       GPU_BLEND_CLIP = 4
+       GPU_BLEND_CLIP = 4,
+       GPU_BLEND_ALPHA_SORT = 8
 } GPUBlendMode;
 
 typedef struct GPUNodeStack {
@@ -121,7 +122,7 @@ int GPU_stack_link(GPUMaterial *mat, const char *name, GPUNodeStack *in, GPUNode
 
 void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link);
 void GPU_material_enable_alpha(GPUMaterial *material);
-GPUBlendMode GPU_material_blend_mode(GPUMaterial *material, float obcol[4]);
+GPUBlendMode GPU_material_alpha_blend(GPUMaterial *material, float obcol[4]);
 
 /* High level functions to create and use GPU materials */
 
index 7af5ef6ea14750a8f94271d9b0be4f2467b1c8af..4f79d577ae5a666d1552352d0c0c397f321073cf 100644 (file)
@@ -95,7 +95,7 @@ void GPU_render_text(MTFace *tface, int mode,
        const char *textstr, int textlen, unsigned int *col,
        float *v1, float *v2, float *v3, float *v4, int glattrib)
 {
-       if ((mode & TF_BMFONT) && (textlen>0) && tface->tpage) {
+       if ((mode & GEMAT_TEXT) && (textlen>0) && tface->tpage) {
                Image* ima = (Image*)tface->tpage;
                int index, character;
                float centerx, centery, sizex, sizey, transx, transy, movex, movey, advance;
@@ -245,7 +245,7 @@ static struct GPUTextureState {
 
        int domipmap, linearmipmap;
 
-       int alphamode;
+       int alphablend;
        float anisotropic;
        MTFace *lasttface;
 } GTS = {0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, 1, 0, -1, 1.f, NULL};
@@ -352,7 +352,7 @@ static void gpu_clear_tpage(void)
        GTS.curtilemode= 0;
        GTS.curtileXRep=0;
        GTS.curtileYRep=0;
-       GTS.alphamode= -1;
+       GTS.alphablend= -1;
        
        glDisable(GL_BLEND);
        glDisable(GL_TEXTURE_2D);
@@ -361,19 +361,19 @@ static void gpu_clear_tpage(void)
        glDisable(GL_ALPHA_TEST);
 }
 
-static void gpu_set_blend_mode(GPUBlendMode blendmode)
+static void gpu_set_alpha_blend(GPUBlendMode alphablend)
 {
-       if(blendmode == GPU_BLEND_SOLID) {
+       if(alphablend == GPU_BLEND_SOLID) {
                glDisable(GL_BLEND);
                glDisable(GL_ALPHA_TEST);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
-       else if(blendmode==GPU_BLEND_ADD) {
+       else if(alphablend==GPU_BLEND_ADD) {
                glEnable(GL_BLEND);
                glBlendFunc(GL_ONE, GL_ONE);
                glDisable(GL_ALPHA_TEST);
        }
-       else if(blendmode==GPU_BLEND_ALPHA) {
+       else if(ELEM(alphablend, GPU_BLEND_ALPHA, GPU_BLEND_ALPHA_SORT)) {
                glEnable(GL_BLEND);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                
@@ -389,21 +389,21 @@ static void gpu_set_blend_mode(GPUBlendMode blendmode)
                        glAlphaFunc(GL_GREATER, U.glalphaclip);
                }
        }
-       else if(blendmode==GPU_BLEND_CLIP) {
+       else if(alphablend==GPU_BLEND_CLIP) {
                glDisable(GL_BLEND); 
                glEnable(GL_ALPHA_TEST);
                glAlphaFunc(GL_GREATER, 0.5f);
        }
 }
 
-static void gpu_verify_alpha_mode(MTFace *tface)
+static void gpu_verify_alpha_blend(int alphablend)
 {
        /* verify alpha blending modes */
-       if(GTS.alphamode == tface->transp)
+       if(GTS.alphablend == alphablend)
                return;
 
-       gpu_set_blend_mode(tface->transp);
-       GTS.alphamode= tface->transp;
+       gpu_set_alpha_blend(alphablend);
+       GTS.alphablend= alphablend;
 }
 
 static void gpu_verify_reflection(Image *ima)
@@ -608,7 +608,7 @@ static void gpu_verify_repeat(Image *ima)
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 }
 
-int GPU_set_tpage(MTFace *tface, int mipmap)
+int GPU_set_tpage(MTFace *tface, int mipmap, int alphablend)
 {
        Image *ima;
        
@@ -621,7 +621,7 @@ int GPU_set_tpage(MTFace *tface, int mipmap)
        ima= tface->tpage;
        GTS.lasttface= tface;
 
-       gpu_verify_alpha_mode(tface);
+       gpu_verify_alpha_blend(alphablend);
        gpu_verify_reflection(ima);
 
        if(GPU_verify_image(ima, NULL, tface->tile, 1, mipmap)) {
@@ -945,12 +945,12 @@ static struct GPUMaterialState {
        float (*gviewmat)[4];
        float (*gviewinv)[4];
 
-       GPUBlendMode *blendmode;
-       GPUBlendMode blendmode_fixed[FIXEDMAT];
+       GPUBlendMode *alphablend;
+       GPUBlendMode alphablend_fixed[FIXEDMAT];
        int alphapass;
 
        int lastmatnr, lastretval;
-       GPUBlendMode lastblendmode;
+       GPUBlendMode lastalphablend;
 } GMS = {NULL};
 
 /* fixed function material, alpha handed by caller */
@@ -1000,7 +1000,7 @@ void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
 {
        Material *ma;
        GPUMaterial *gpumat;
-       GPUBlendMode blendmode;
+       GPUBlendMode alphablend;
        int a;
        int gamma = scene->r.color_mgt_flag & R_COLOR_MANAGEMENT;
        
@@ -1008,7 +1008,7 @@ void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
        memset(&GMS, 0, sizeof(GMS));
        GMS.lastmatnr = -1;
        GMS.lastretval = -1;
-       GMS.lastblendmode = GPU_BLEND_SOLID;
+       GMS.lastalphablend = GPU_BLEND_SOLID;
 
        GMS.gob = ob;
        GMS.gscene = scene;
@@ -1024,12 +1024,12 @@ void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
        if(GMS.totmat > FIXEDMAT) {
                GMS.matbuf= MEM_callocN(sizeof(GPUMaterialFixed)*GMS.totmat, "GMS.matbuf");
                GMS.gmatbuf= MEM_callocN(sizeof(*GMS.gmatbuf)*GMS.totmat, "GMS.matbuf");
-               GMS.blendmode= MEM_callocN(sizeof(*GMS.blendmode)*GMS.totmat, "GMS.matbuf");
+               GMS.alphablend= MEM_callocN(sizeof(*GMS.alphablend)*GMS.totmat, "GMS.matbuf");
        }
        else {
                GMS.matbuf= GMS.matbuf_fixed;
                GMS.gmatbuf= GMS.gmatbuf_fixed;
-               GMS.blendmode= GMS.blendmode_fixed;
+               GMS.alphablend= GMS.alphablend_fixed;
        }
 
        /* no materials assigned? */
@@ -1044,7 +1044,7 @@ void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
                        GPU_material_from_blender(GMS.gscene, &defmaterial);
                }
 
-               GMS.blendmode[0]= GPU_BLEND_SOLID;
+               GMS.alphablend[0]= GPU_BLEND_SOLID;
        }
        
        /* setup materials */
@@ -1060,13 +1060,13 @@ void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
                if(gpumat) {
                        /* do glsl only if creating it succeed, else fallback */
                        GMS.gmatbuf[a]= ma;
-                       blendmode = GPU_material_blend_mode(gpumat, ob->col);
+                       alphablend = GPU_material_alpha_blend(gpumat, ob->col);
                }
                else {
                        /* fixed function opengl materials */
                        gpu_material_to_fixed(&GMS.matbuf[a], ma, gamma, ob);
 
-                       blendmode = (ma->alpha == 1.0f)? GPU_BLEND_SOLID: GPU_BLEND_ALPHA;
+                       alphablend = (ma->alpha == 1.0f)? GPU_BLEND_SOLID: GPU_BLEND_ALPHA;
                        if(do_alpha_pass && GMS.alphapass)
                                GMS.matbuf[a].diff[3]= ma->alpha;
                        else
@@ -1076,8 +1076,8 @@ void GPU_begin_object_materials(View3D *v3d, RegionView3D *rv3d, Scene *scene, O
                /* setting do_alpha_pass = 1 indicates this object needs to be
                 * drawn in a second alpha pass for improved blending */
                if(do_alpha_pass) {
-                       GMS.blendmode[a]= blendmode;
-                       if(ELEM(blendmode, GPU_BLEND_ALPHA, GPU_BLEND_ADD) && !GMS.alphapass)
+                       GMS.alphablend[a]= alphablend;
+                       if(ELEM3(alphablend, GPU_BLEND_ALPHA, GPU_BLEND_ADD, GPU_BLEND_ALPHA_SORT) && !GMS.alphapass)
                                *do_alpha_pass= 1;
                }
        }
@@ -1090,7 +1090,7 @@ int GPU_enable_material(int nr, void *attribs)
 {
        GPUVertexAttribs *gattribs = attribs;
        GPUMaterial *gpumat;
-       GPUBlendMode blendmode;
+       GPUBlendMode alphablend;
 
        /* no GPU_begin_object_materials, use default material */
        if(!GMS.matbuf) {
@@ -1131,7 +1131,7 @@ int GPU_enable_material(int nr, void *attribs)
 
        /* draw materials with alpha in alpha pass */
        GMS.lastmatnr = nr;
-       GMS.lastretval = ELEM(GMS.blendmode[nr], GPU_BLEND_SOLID, GPU_BLEND_CLIP);
+       GMS.lastretval = ELEM(GMS.alphablend[nr], GPU_BLEND_SOLID, GPU_BLEND_CLIP);
        if(GMS.alphapass)
                GMS.lastretval = !GMS.lastretval;
 
@@ -1145,6 +1145,7 @@ int GPU_enable_material(int nr, void *attribs)
                        GPU_material_bind(gpumat, GMS.gob->lay, GMS.glay, 1.0, !(GMS.gob->mode & OB_MODE_TEXTURE_PAINT));
                        GPU_material_bind_uniforms(gpumat, GMS.gob->obmat, GMS.gviewmat, GMS.gviewinv, GMS.gob->col);
                        GMS.gboundmat= mat;
+                       alphablend= mat->game.alpha_blend;
 
                        if(GMS.alphapass) glDepthMask(1);
                }
@@ -1153,28 +1154,29 @@ int GPU_enable_material(int nr, void *attribs)
                        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, GMS.matbuf[nr].diff);
                        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, GMS.matbuf[nr].spec);
                        glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, GMS.matbuf[nr].hard);
+                       alphablend= GPU_BLEND_SOLID;
                }
 
                /* set (alpha) blending mode */
-               blendmode = (GMS.alphapass)? GPU_BLEND_ALPHA: GPU_BLEND_SOLID;
-               GPU_set_material_blend_mode(blendmode);
+               if(!GMS.alphapass) alphablend= GPU_BLEND_SOLID;
+               GPU_set_material_alpha_blend(alphablend);
        }
 
        return GMS.lastretval;
 }
 
-void GPU_set_material_blend_mode(int blendmode)
+void GPU_set_material_alpha_blend(int alphablend)
 {
-       if(GMS.lastblendmode == blendmode)
+       if(GMS.lastalphablend == alphablend)
                return;
        
-       gpu_set_blend_mode(blendmode);
-       GMS.lastblendmode = blendmode;
+       gpu_set_alpha_blend(alphablend);
+       GMS.lastalphablend = alphablend;
 }
 
-int GPU_get_material_blend_mode(void)
+int GPU_get_material_alpha_blend(void)
 {
-       return GMS.lastblendmode;
+       return GMS.lastalphablend;
 }
 
 void GPU_disable_material(void)
@@ -1188,7 +1190,7 @@ void GPU_disable_material(void)
                GMS.gboundmat= NULL;
        }
 
-       GPU_set_material_blend_mode(GPU_BLEND_SOLID);
+       GPU_set_material_alpha_blend(GPU_BLEND_SOLID);
 }
 
 void GPU_end_object_materials(void)
@@ -1198,12 +1200,12 @@ void GPU_end_object_materials(void)
        if(GMS.matbuf && GMS.matbuf != GMS.matbuf_fixed) {
                MEM_freeN(GMS.matbuf);
                MEM_freeN(GMS.gmatbuf);
-               MEM_freeN(GMS.blendmode);
+               MEM_freeN(GMS.alphablend);
        }
 
        GMS.matbuf= NULL;
        GMS.gmatbuf= NULL;
-       GMS.blendmode= NULL;
+       GMS.alphablend= NULL;
 
        /* resetting the texture matrix after the glScale needed for tiled textures */
        if(GTS.tilemode)
index 9aa453af4d6bf5b0289780d40deb56424f3f95ff..40186c5a18760b8be840e441ec2604a69e333d3e 100644 (file)
@@ -358,7 +358,7 @@ void GPU_material_enable_alpha(GPUMaterial *material)
        material->alpha= 1;
 }
 
-GPUBlendMode GPU_material_blend_mode(GPUMaterial *material, float obcol[4])
+GPUBlendMode GPU_material_alpha_blend(GPUMaterial *material, float obcol[4])
 {
        if(material->alpha || (material->obcolalpha && obcol[3] < 1.0f))
                return GPU_BLEND_ALPHA;
index 060b1bf42d1228bd4818fb1a0815ee9deb957393..09255adb82944a139607dd93ae49142b8fefea5f 100644 (file)
@@ -74,6 +74,14 @@ typedef struct VolumeSettings {
        float ms_spread;
 } VolumeSettings;
 
+/* Game Engine Options (old Texface mode, transp and flag) */
+typedef struct GameSettings {
+       int flag;
+       int alpha_blend;
+       int face_orientation;
+       int pad1;
+} GameSettings;
+
 typedef struct Material {
        ID id;
        struct AnimData *adt;   /* animation data (must be immediately after id for utilities to use it) */ 
@@ -90,6 +98,7 @@ typedef struct Material {
        /* end synced with render_types.h */
        
        struct VolumeSettings vol;
+       struct GameSettings game;
 
        float fresnel_mir, fresnel_mir_i;
        float fresnel_tra, fresnel_tra_i;
@@ -166,6 +175,32 @@ typedef struct Material {
        ListBase gpumaterial;           /* runtime */
 } Material;
 
+
+/* **************** GAME PROPERTIES ********************* */
+// Blend Transparency Options - alpha_blend /* match GPU_material::GPUBlendMode */
+#define GEMAT_SOLID            0 /* GPU_BLEND_SOLID */
+#define GEMAT_ADD              1 /* GPU_BLEND_ADD */
+#define        GEMAT_ALPHA             2 /* GPU_BLEND_ALPHA */
+#define GEMAT_CLIP             4 /* GPU_BLEND_CLIP */
+#define        GEMAT_ALPHA_SORT        8 /* GPU_BLEND_ALPHA_SORT */
+
+// Game Options - flag
+#define GEMAT_BACKCULL                 16 /* KX_BACKCULL */
+#define GEMAT_SHADED           32 /* KX_LIGHT */
+#define GEMAT_TEXT             64 /* RAS_RENDER_3DPOLYGON_TEXT */
+#define        GEMAT_NOPHYSICS         128
+#define GEMAT_INVISIBLE        256
+
+// Face Orientation Options - face_orientation
+#define GEMAT_NORMAL           0
+#define GEMAT_HALO             512  /* BILLBOARD_SCREENALIGNED  */
+#define GEMAT_BILLBOARD                1024 /* BILLBOARD_AXISALIGNED */
+#define GEMAT_SHADOW           2048 /* SHADOW */
+
+// Use Textures - not defined directly in the UI
+#define GEMAT_TEX              4096 /* KX_TEX */
+
+
 /* **************** MATERIAL ********************* */
 
 /* maximum number of materials per material array.
index 61c4a6609929bf1ba0e955aaf27246c38a7dabff..9d7375b6755e2b9e420c52fd376d35d7becc95e0 100644 (file)
@@ -247,6 +247,8 @@ typedef struct MRecast{
 #define TF_SHAREDVERT  8
 #define TF_LIGHT               16
 
+#define TF_CONVERTED 32 /* tface converted to material */
+
 #define TF_SHAREDCOL   64
 #define TF_TILES               128             /* deprecated */
 #define TF_BILLBOARD   256
index dcaeb523df53cd932f029fdecb776561f052fb31..673e768e71ef8bd8a0713dd835c0d1529fef96d1 100644 (file)
@@ -742,6 +742,61 @@ static void rna_def_material_mtex(BlenderRNA *brna)
        RNA_def_property_update(prop, 0, "rna_Material_update");
 }
 
+static void rna_def_material_gamesettings(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       static EnumPropertyItem prop_alpha_blend_items[] = {
+               {GEMAT_SOLID, "OPAQUE", 0, "Opaque", "Render color of textured face as color"},
+               {GEMAT_ADD, "ADD", 0, "Add", "Render face transparent and add color of face"},
+               {GEMAT_CLIP, "CLIP", 0, "Alpha Clip", "Use the image alpha values clipped with no blending (binary alpha)"},
+               {GEMAT_ALPHA, "ALPHA", 0, "Alpha Blend", "Render polygon transparent, depending on alpha channel of the texture"},
+               {GEMAT_ALPHA_SORT, "ALPHA_SORT", 0, "Alpha Sort", "Sort faces for correct alpha drawing (slow, use Alpha Clip instead when possible)"},         
+               {0, NULL, 0, NULL, NULL}};
+
+       static EnumPropertyItem prop_face_orientation_items[] = {
+               {GEMAT_NORMAL,"NORMAL",0,"Normal","No tranformation"},
+               {GEMAT_HALO, "HALO", 0, "Halo", "Screen aligned billboard"},
+               {GEMAT_BILLBOARD, "BILLBOARD", 0, "Billboard", "Billboard with Z-axis constraint"},
+               {GEMAT_SHADOW, "SHADOW", 0, "Shadow", "Faces are used for shadow"},             
+               {0, NULL, 0, NULL, NULL}};
+       
+       srna= RNA_def_struct(brna, "MaterialGameSettings", NULL);
+       RNA_def_struct_sdna(srna, "GameSettings");
+       RNA_def_struct_nested(brna, srna, "Material");
+       RNA_def_struct_ui_text(srna, "Material Game Settings", "Game Engine settings for a Material datablock");
+       
+       prop= RNA_def_property(srna, "back_culling", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", GEMAT_BACKCULL); /* use bitflags */
+       RNA_def_property_ui_text(prop, "Back Culling", "Hide Back of the face in Game Engine ");
+       RNA_def_property_update(prop, 0, "rna_Material_draw_update");
+
+       prop= RNA_def_property(srna, "text", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", GEMAT_TEXT); /* use bitflags */
+       RNA_def_property_ui_text(prop, "Text", "Use material as text in Game Engine ");
+       RNA_def_property_update(prop, 0, "rna_Material_draw_update");
+
+       prop= RNA_def_property(srna, "invisible", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", GEMAT_INVISIBLE); /* use bitflags */
+       RNA_def_property_ui_text(prop, "Invisible", "Make face invisible");
+       RNA_def_property_update(prop, 0, "rna_Material_draw_update");
+
+       prop= RNA_def_property(srna, "alpha_blend", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "alpha_blend");
+       RNA_def_property_enum_items(prop, prop_alpha_blend_items);
+       RNA_def_property_ui_text(prop, "Blend Mode", "Blend Mode for Transparent Faces");
+       RNA_def_property_update(prop, 0, "rna_Material_draw_update");
+
+       prop= RNA_def_property(srna, "face_orientation", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_items(prop, prop_face_orientation_items);
+       RNA_def_property_ui_text(prop, "Face Orientations", "Especial face orientation options");
+
+       prop= RNA_def_property(srna, "physics", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GEMAT_NOPHYSICS); /* use bitflags */
+       RNA_def_property_ui_text(prop, "Physics", "Use physics properties of materials ");
+}
+
 static void rna_def_material_colors(StructRNA *srna)
 {
        PropertyRNA *prop;
@@ -1887,6 +1942,13 @@ void RNA_def_material(BlenderRNA *brna)
        RNA_def_property_pointer_funcs(prop, "rna_Material_physics_get", NULL, NULL, NULL);
        RNA_def_property_ui_text(prop, "Physics", "Game physics settings");
 
+       /* game settings */
+       prop= RNA_def_property(srna, "game_settings", PROP_POINTER, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NEVER_NULL);
+       RNA_def_property_pointer_sdna(prop, NULL, "game");
+       RNA_def_property_struct_type(prop, "MaterialGameSettings");
+       RNA_def_property_ui_text(prop, "Game Settings", "Game material settings");
+
        /* nodetree */
        prop= RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
@@ -1932,6 +1994,7 @@ void RNA_def_material(BlenderRNA *brna)
        rna_def_material_mtex(brna);
        rna_def_material_strand(brna);
        rna_def_material_physics(brna);
+       rna_def_material_gamesettings(brna);
 
        RNA_api_material(srna);
 }
index 5466e758023f4a824fa84315bdab5839ac788085..1bbdc7cc853e70496ea3595d7eeffaad564522e0 100644 (file)
@@ -1420,6 +1420,9 @@ static void rna_def_mtface(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Image", "");
        RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
 
+       //XXX to be deleted soon -- left for now in case we need it for debug
+       //XXX it should be out before Blender 2.6 (after texface to material patch)
+
        prop= RNA_def_property(srna, "use_image", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_TEX);
        RNA_def_property_ui_text(prop, "Tex", "Render face with texture");
@@ -1486,6 +1489,9 @@ static void rna_def_mtface(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Transparency", "Transparency blending mode");
        RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
 
+       //XXX to be deleted soon -- left for now in case we need it for debug
+       //XXX it should be out before Blender 2.6 (after texface to material patch)
+
        prop= RNA_def_property(srna, "select_uv", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", TF_SEL1);
        RNA_def_property_array(prop, 4);
index 873d61eba0690dd6b0a8a87849ccbb533715628f..774e21297da88e915f0a690cdb2cd7df322bc8f3 100644 (file)
@@ -1828,7 +1828,7 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
                {0, NULL, 0, NULL, NULL}};
 
        static EnumPropertyItem material_items[] ={
-               {GAME_MAT_TEXFACE, "TEXTURE_FACE", 0, "Texture Face", "Single texture face materials"},
+               {GAME_MAT_TEXFACE, "SINGLETEXTURE", 0, "Singletexture", "Singletexture face materials"},
                {GAME_MAT_MULTITEX, "MULTITEXTURE", 0, "Multitexture", "Multitexture materials"},
                {GAME_MAT_GLSL, "GLSL", 0, "GLSL", "OpenGL shading language shaders"},
                {0, NULL, 0, NULL, NULL}};
index 912c14adfdd8a079446d3810a8c52738935ca79e..0c34333273607642fcebd72f304aa7681af053f8 100644 (file)
@@ -369,7 +369,6 @@ static DerivedMesh *uvprojectModifier_do(UVProjectModifierData *umd,
                }
 
                if(override_image) {
-                       tface->mode = TF_TEX;
                        tface->tpage = image;
                }
        }
index d4b43cd7ac17438fc4bf4f9fe0bfb22480cf362c..2c2fd052b5db3ee779c6558b8683d6429abbe5dc 100644 (file)
@@ -144,6 +144,8 @@ extern "C" {
 #include "BKE_cdderivedmesh.h"
 #include "BKE_DerivedMesh.h"
 #include "BKE_material.h" /* give_current_material */
+#include "BKE_image.h"
+#include "IMB_imbuf_types.h"
 
 extern Material defmaterial;   /* material.c */
 }
@@ -195,7 +197,7 @@ extern "C" {
 }
 #endif
 
-static int default_face_mode = TF_DYNAMIC;
+static bool default_light_mode = 0;
 
 static unsigned int KX_rgbaint2uint_new(unsigned int icol)
 {
@@ -234,9 +236,9 @@ static unsigned int KX_Mcol2uint_new(MCol col)
        return out_color.integer;
 }
 
-static void SetDefaultFaceType(Scene* scene)
+static void SetDefaultLightMode(Scene* scene)
 {
-       default_face_mode = TF_DYNAMIC;
+       default_light_mode = false;
        Scene *sce_iter;
        Base *base;
 
@@ -244,7 +246,7 @@ static void SetDefaultFaceType(Scene* scene)
        {
                if (base->object->type == OB_LAMP)
                {
-                       default_face_mode = TF_DYNAMIC|TF_LIGHT;
+                       default_light_mode = true;
                        return;
                }
        }
@@ -353,41 +355,41 @@ bool ConvertMaterial(
 
                // use lighting?
                material->ras_mode |= ( mat->mode & MA_SHLESS )?0:USE_LIGHT;
+               material->ras_mode |= ( mat->game.flag & GEMAT_BACKCULL )?0:TWOSIDED;
+
                // cast shadows?
                material->ras_mode |= ( mat->mode & MA_SHADBUF )?CAST_SHADOW:0;
                MTex *mttmp = 0;
                numchan = getNumTexChannels(mat);
                int valid_index = 0;
                
-               // use the face texture if
-               // 1) it is set in the buttons
-               // 2) we have a face texture and a material but no valid texture in slot 1
+               /* In Multitexture use the face texture if and only if
+                it is set in the buttons
+               *  In GLSL is not working yet :/ 3.2011 */
                bool facetex = false;
                if(validface && mat->mode &MA_FACETEXTURE) 
                        facetex = true;
-               if(validface && !mat->mtex[0])
-                       facetex = true;
-               if(validface && mat->mtex[0]) {
-                       MTex *tmp = mat->mtex[0];
-                       if(!tmp->tex || (tmp->tex && !tmp->tex->ima))
-                               facetex = true;
-               }
+
                numchan = numchan>MAXTEX?MAXTEX:numchan;
+               if (facetex && numchan == 0) numchan = 1;
        
                // foreach MTex
                for(int i=0; i<numchan; i++) {
                        // use face tex
 
                        if(i==0 && facetex ) {
+                               facetex = false;
                                Image*tmp = (Image*)(tface->tpage);
 
                                if(tmp) {
                                        material->img[i] = tmp;
                                        material->texname[i] = material->img[i]->id.name;
-                                       material->flag[i] |= ( tface->transp  &TF_ALPHA )?USEALPHA:0;
-                                       material->flag[i] |= ( tface->transp  &TF_ADD   )?CALCALPHA:0;
                                        material->flag[i] |= MIPMAP;
 
+                                       material->flag[i] |= ( mat->game.alpha_blend & GEMAT_ALPHA_SORT )?USEALPHA:0;
+                                       material->flag[i] |= ( mat->game.alpha_blend & GEMAT_ALPHA )?USEALPHA:0;
+                                       material->flag[i] |= ( mat->game.alpha_blend & GEMAT_ADD )?CALCALPHA:0;
+
                                        if(material->img[i]->flag & IMA_REFLECT)
                                                material->mapping[i].mapping |= USEREFL;
                                        else
@@ -405,11 +407,6 @@ bool ConvertMaterial(
                                                material->mapping[i].mapping |= USEUV;
                                        }
 
-                                       if(material->ras_mode & USE_LIGHT)
-                                               material->ras_mode &= ~USE_LIGHT;
-                                       if(tface->mode & TF_LIGHT)
-                                               material->ras_mode |= USE_LIGHT;
-
                                        valid_index++;
                                }
                                else {
@@ -567,25 +564,31 @@ bool ConvertMaterial(
 
                material->ras_mode |= (mat->material_type == MA_TYPE_WIRE)? WIRE: 0;
        }
-       else {
+       else { // No Material
                int valid = 0;
 
                // check for tface tex to fallback on
                if( validface ){
-
-                       // no light bugfix
-                       if(tface->mode) material->ras_mode |= USE_LIGHT;
-
                        material->img[0] = (Image*)(tface->tpage);
                        // ------------------------
                        if(material->img[0]) {
                                material->texname[0] = material->img[0]->id.name;
                                material->mapping[0].mapping |= ( (material->img[0]->flag & IMA_REFLECT)!=0 )?USEREFL:0;
-                               material->flag[0] |= ( tface->transp  &TF_ALPHA )?USEALPHA:0;
-                               material->flag[0] |= ( tface->transp  &TF_ADD   )?CALCALPHA:0;
+
+                               /* see if depth of the image is 32bits */
+                               if(BKE_image_has_alpha(material->img[0])) {
+                                       material->flag[0] |= USEALPHA;
+                                       material->alphablend = GEMAT_ALPHA;
+                               }
+                               else
+                                       material->alphablend = GEMAT_SOLID;
+
                                valid++;
                        }
                }
+               else
+                       material->alphablend = GEMAT_SOLID;
+
                material->SetUsers(-1);
                material->num_enabled   = valid;
                material->IdMode                = TEXFACE;
@@ -598,6 +601,9 @@ bool ConvertMaterial(
                material->matcolor[2]   = 0.5f;
                material->spec_f                = 0.5f;
                material->ref                   = 0.8f;
+
+               // No material - old default TexFace properties
+               material->ras_mode |= USE_LIGHT;
        }
        MT_Point2 uv[4];
        MT_Point2 uv2[4];
@@ -606,13 +612,10 @@ bool ConvertMaterial(
        
        uv2[0]= uv2[1]= uv2[2]= uv2[3]= MT_Point2(0.0f, 0.0f);
 
+       /*  No material, what to do? let's see what is in the UV and set the material accordingly
+               light and visible is always on */
        if( validface ) {
-
-               material->ras_mode |= (tface->mode & TF_INVISIBLE)?0:POLY_VIS;
-
-               material->transp = tface->transp;
                material->tile  = tface->tile;
-               material->mode  = tface->mode;
                        
                uv[0].setValue(tface->uv[0]);
                uv[1].setValue(tface->uv[1]);
@@ -625,31 +628,26 @@ bool ConvertMaterial(
        } 
        else {
                // nothing at all
-               material->ras_mode |= (POLY_VIS| (validmat?0:USE_LIGHT));
-               material->mode          = default_face_mode;    
-               material->transp        = TF_SOLID;
+               material->alphablend    = GEMAT_SOLID;
                material->tile          = 0;
                
                uv[0]= uv[1]= uv[2]= uv[3]= MT_Point2(0.0f, 0.0f);
        }
 
+       if (validmat && validface) {
+               material->alphablend = mat->game.alpha_blend;
+       }
+
        // with ztransp enabled, enforce alpha blending mode
-       if(validmat && (mat->mode & MA_TRANSP) && (mat->mode & MA_ZTRANSP) && (material->transp == TF_SOLID))
-               material->transp = TF_ALPHA;
+       if(validmat && (mat->mode & MA_TRANSP) && (mat->mode & MA_ZTRANSP) && (material->alphablend == GEMAT_SOLID))
+               material->alphablend = GEMAT_ALPHA;
 
        // always zsort alpha + add
-       if((material->transp == TF_ALPHA || material->transp == TF_ADD || texalpha) && (material->transp != TF_CLIP)) {
+       if((ELEM3(material->alphablend, GEMAT_ALPHA, GEMAT_ALPHA_SORT, GEMAT_ADD) || texalpha) && (material->alphablend != GEMAT_CLIP )) {
                material->ras_mode |= ALPHA;
-               material->ras_mode |= (material->mode & TF_ALPHASORT)? ZSORT: 0;
+               material->ras_mode |= (mat && (mat->game.alpha_blend & GEMAT_ALPHA_SORT))? ZSORT: 0;
        }
 
-       // collider or not?
-       material->ras_mode |= (material->mode & TF_DYNAMIC)? COLLIDER: 0;
-
-       // these flags are irrelevant at this point, remove so they
-       // don't hurt material bucketing 
-       material->mode &= ~(TF_DYNAMIC|TF_ALPHASORT|TF_TEX);
-
        // get uv sets
        if(validmat) 
        {
@@ -706,8 +704,8 @@ bool ConvertMaterial(
        unsigned int rgb[4];
        GetRGB(type,mface,mmcol,mat,rgb[0],rgb[1],rgb[2], rgb[3]);
 
-       // swap the material color, so MCol on TF_BMFONT works
-       if (validmat && type==1 && (tface && tface->mode & TF_BMFONT))
+       // swap the material color, so MCol on bitmap font works
+       if (validmat && type==1 && (mat->game.flag & GEMAT_TEXT))
        {
                rgb[0] = KX_rgbaint2uint_new(rgb[0]);
                rgb[1] = KX_rgbaint2uint_new(rgb[1]);
@@ -864,10 +862,6 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, KX_Scene* scene,
                                ConvertMaterial(bl_mat, ma, tface, tfaceName, mface, mcol,
                                        layers, converter->GetGLSLMaterials());
 
-                               visible = ((bl_mat->ras_mode & POLY_VIS)!=0);
-                               collider = ((bl_mat->ras_mode & COLLIDER)!=0);
-                               twoside = ((bl_mat->mode & TF_TWOSIDE)!=0);
-
                                /* vertex colors and uv's were stored in bl_mat temporarily */
                                bl_mat->GetConversionRGB(rgb);
                                rgb0 = rgb[0]; rgb1 = rgb[1];
@@ -885,7 +879,7 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, KX_Scene* scene,
                                if (kx_blmat == NULL)
                                        kx_blmat = new KX_BlenderMaterial();
 
-                               kx_blmat->Initialize(scene, bl_mat);
+                               kx_blmat->Initialize(scene, bl_mat, (ma?&ma->game:NULL));
                                polymat = static_cast<RAS_IPolyMaterial*>(kx_blmat);
                        }
                        else {
@@ -893,37 +887,59 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, KX_Scene* scene,
                                Image* bima = (tface)? (Image*)tface->tpage: NULL;
                                imastr =  (tface)? (bima? (bima)->id.name : "" ) : "";
                
-                               char transp=0;
-                               short mode=0, tile=0;
+                               char alpha_blend=0;
+                               short tile=0;
                                int     tilexrep=4,tileyrep = 4;
-                               
+
+                               /* set material properties - old TexFace */
+                               if (ma) {
+                                       alpha_blend = ma->game.alpha_blend;
+                                       /* Commented out for now. If we ever get rid of
+                                        * "Texture Face/Singletexture" we can then think about it */
+
+                                       /* Texture Face mode ignores texture but requires "Face Textures to be True "*/
+                                       /**
+                                       if ((ma->mode &MA_FACETEXTURE)==0 && (ma->game.flag &GEMAT_TEXT)==0) {
+                                               bima = NULL;
+                                               imastr = "";
+                                               alpha_blend = GEMAT_SOLID;       
+                                       }
+                                       else
+                                               alpha_blend = ma->game.alpha_blend;
+                                       */
+                               }
+                               /* check for tface tex to fallback on */
+                               else {
+                                       if (bima) {
+                                               /* see if depth of the image is 32 */
+                                               if (BKE_image_has_alpha(bima))
+                                                       alpha_blend = GEMAT_ALPHA;
+                                               else
+                                                       alpha_blend = GEMAT_SOLID;
+                                       }
+                                       else {
+                                               alpha_blend = GEMAT_SOLID;
+                                       }
+                               }
+
                                if (bima) {
                                        tilexrep = bima->xrep;
                                        tileyrep = bima->yrep;
                                }
 
-                               /* get tface properties if available */
+                               /* set UV properties */
                                if(tface) {
-                                       /* TF_DYNAMIC means the polygon is a collision face */
-                                       collider = ((tface->mode & TF_DYNAMIC) != 0);
-                                       transp = tface->transp;
-                                       tile = tface->tile;
-                                       mode = tface->mode;
-                                       
-                                       visible = !(tface->mode & TF_INVISIBLE);
-                                       twoside = ((tface->mode & TF_TWOSIDE)!=0);
-                                       
                                        uv0.setValue(tface->uv[0]);
                                        uv1.setValue(tface->uv[1]);
                                        uv2.setValue(tface->uv[2]);
        
                                        if (mface->v4)
                                                uv3.setValue(tface->uv[3]);
+
+                                       tile = tface->tile;
                                } 
                                else {
-                                       /* no texfaces, set COLLSION true and everything else FALSE */
-                                       mode = default_face_mode;       
-                                       transp = TF_SOLID;
+                                       /* no texfaces */
                                        tile = 0;
                                }
 
@@ -964,16 +980,20 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, KX_Scene* scene,
                                        if (mface->v4)
                                                rgb3 = KX_rgbaint2uint_new(color);
                                }
-                               
+
                                // only zsort alpha + add
-                               bool alpha = (transp == TF_ALPHA || transp == TF_ADD);
-                               bool zsort = (mode & TF_ALPHASORT)? alpha: 0;
+                               bool alpha = ELEM3(alpha_blend, GEMAT_ALPHA, GEMAT_ADD, GEMAT_ALPHA_SORT);
+                               bool zsort = (alpha_blend == GEMAT_ALPHA_SORT);
+                               bool light = (ma)?(ma->mode & MA_SHLESS)==0:default_light_mode;
+
+                               // don't need zort anymore, deal as if it it's alpha blend
+                               if (alpha_blend == GEMAT_ALPHA_SORT) alpha_blend = GEMAT_ALPHA;
 
                                if (kx_polymat == NULL)
                                        kx_polymat = new KX_PolygonMaterial();
                                kx_polymat->Initialize(imastr, ma, (int)mface->mat_nr,
                                        tile, tilexrep, tileyrep, 
-                                       mode, transp, alpha, zsort, lightlayer, tface, (unsigned int*)mcol);
+                                       alpha_blend, alpha, zsort, light, lightlayer, tface, (unsigned int*)mcol);
                                polymat = static_cast<RAS_IPolyMaterial*>(kx_polymat);
        
                                if (ma) {
@@ -987,6 +1007,19 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, KX_Scene* scene,
                                }
                        }
 
+                       // set render flags
+                       if (ma)
+                       {
+                               visible = ((ma->game.flag & GEMAT_INVISIBLE)==0);
+                               twoside = ((ma->game.flag  & GEMAT_BACKCULL)==0);
+                               collider = ((ma->game.flag & GEMAT_NOPHYSICS)==0);
+                       }
+                       else{
+                               visible = true;
+                               twoside = false;
+                               collider = true;
+                       }
+
                        /* mark face as flat, so vertices are split */
                        bool flat = (mface->flag & ME_SMOOTH) == 0;
 
@@ -2035,7 +2068,7 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
                logicmgr->RegisterActionName(curAct->id.name + 2, curAct);
        }
 
-       SetDefaultFaceType(blenderscene);
+       SetDefaultLightMode(blenderscene);
        // Let's support scene set.
        // Beware of name conflict in linked data, it will not crash but will create confusion
        // in Python scripting and in certain actuators (replace mesh). Linked scene *should* have
index 4ae937cdcd6e5bfe0599006c5cf93a694afb911c..6680e9556b9d70de2b6a291458ff57c3a4555bcc 100644 (file)
@@ -27,7 +27,7 @@ BL_BlenderShader::BL_BlenderShader(KX_Scene *scene, struct Material *ma, int lig
        mGPUMat(NULL)
 {
        mBlenderScene = scene->GetBlenderScene();
-       mBlendMode = GPU_BLEND_SOLID;
+       mAlphaBlend = GPU_BLEND_SOLID;
 
        ReloadMaterial();
 }
@@ -148,12 +148,12 @@ void BL_BlenderShader::Update(const RAS_MeshSlot & ms, RAS_IRasterizer* rasty )
 
        GPU_material_bind_uniforms(gpumat, obmat, viewmat, viewinvmat, obcol);
 
-       mBlendMode = GPU_material_blend_mode(gpumat, obcol);
+       mAlphaBlend = GPU_material_alpha_blend(gpumat, obcol);
 }
 
-int BL_BlenderShader::GetBlendMode()
+int BL_BlenderShader::GetAlphaBlend()
 {
-       return mBlendMode;
+       return mAlphaBlend;
 }
 
 bool BL_BlenderShader::Equals(BL_BlenderShader *blshader)
index 2f22e121b8c0e084b2a4902d4382c32ecd15170d..f187d93d6489d2e0a95877c04b38ce340231080d 100644 (file)
@@ -63,7 +63,7 @@ private:
        struct Scene    *mBlenderScene;
        struct Material *mMat;
        int                             mLightLayer;
-       int                             mBlendMode;
+       int                             mAlphaBlend;
        GPUMaterial     *mGPUMat;
 
        bool                    VerifyShader() 
@@ -86,7 +86,7 @@ public:
        void SetAttribs(class RAS_IRasterizer* ras, const BL_Material *mat);
        void Update(const class RAS_MeshSlot & ms, class RAS_IRasterizer* rasty);
        void ReloadMaterial();
-       int GetBlendMode();
+       int GetAlphaBlend();
 
        void SetScene(KX_Scene *scene)
        {
index 25fd5467e938ff94cf4364e4b109994e8b8f9948..fd0756d067d2d3fef3078dce7c171c82e751bdbb 100644 (file)
@@ -52,12 +52,11 @@ void BL_Material::Initialize()
        speccolor[0] = 1.f;
        speccolor[1] = 1.f;
        speccolor[2] = 1.f;
-       transp = 0;
+       alphablend = 0;
        hard = 50.f;
        spec_f = 0.5f;
        alpha = 1.f;
        emit = 0.f;
-       mode = 0;
        material = 0;
        tface = 0;
        materialindex = 0;
index c0440e665018b9f445e10a9cfc063177bb6f091f..2c6316ea32b2e1042b8cb4b9e11d5ca29c29478e 100644 (file)
@@ -68,7 +68,7 @@ public:
 
        float matcolor[4];
        float speccolor[3];
-       short transp, pad;
+       short alphablend, pad;
 
        float hard, spec_f;
        float alpha, emit, color_blend[MAXTEX], ref;
@@ -76,7 +76,6 @@ public:
 
        int blend_mode[MAXTEX];
 
-       int      mode;
        int num_enabled;
        
        BL_Mapping      mapping[MAXTEX];
@@ -151,14 +150,16 @@ enum BL_flag
 // BL_Material::ras_mode
 enum BL_ras_mode
 {
-       POLY_VIS=1,
+       // POLY_VIS=1,
        COLLIDER=2,
        ZSORT=4,
        ALPHA=8,
        // TRIANGLE=16,
        USE_LIGHT=32,
        WIRE=64,
-       CAST_SHADOW=128
+       CAST_SHADOW=128,
+       TEX=256,
+       TWOSIDED=512
 };
 
 // -------------------------------------
index 33da17cc50547323c4d280c799bc960bf72b0b23..1a1e046f54c0fc806a03ec9c5d7105cc4583295f 100644 (file)
@@ -34,6 +34,8 @@
 #include "DNA_meshdata_types.h"
 #include "BKE_mesh.h"
 // ------------------------------------
+#include "BLI_utildefines.h"
+
 #define spit(x) std::cout << x << std::endl;
 
 BL_Shader *KX_BlenderMaterial::mLastShader = NULL;
@@ -56,21 +58,24 @@ KX_BlenderMaterial::KX_BlenderMaterial()
 }
 
 void KX_BlenderMaterial::Initialize(
-        KX_Scene *scene,
-        BL_Material *data)
+       KX_Scene *scene,
+       BL_Material *data,
+       GameSettings *game)
 {
        RAS_IPolyMaterial::Initialize(
-                   data->texname[0],
-                   data->matname,
-                   data->materialindex,
-                   data->tile,
-                   data->tilexrep[0],
-                   data->tileyrep[0],
-                   data->mode,
-                   data->transp,
-                   ((data->ras_mode &ALPHA)!=0),
-                   ((data->ras_mode &ZSORT)!=0)
-                   );
+               data->texname[0],
+               data->matname,
+               data->materialindex,
+               data->tile,
+               data->tilexrep[0],
+               data->tileyrep[0],
+               data->alphablend,
+               ((data->ras_mode &ALPHA)!=0),
+               ((data->ras_mode &ZSORT)!=0),
+               ((data->ras_mode &USE_LIGHT)!=0),
+               ((data->ras_mode &TEX)),
+               game
+       );
        mMaterial = data;
        mShader = 0;
        mBlenderShader = 0;
@@ -99,7 +104,7 @@ void KX_BlenderMaterial::Initialize(
        for(int i=0; i<mMaterial->num_enabled; i++) {
                m_multimode     += (mMaterial->flag[i] + mMaterial->blend_mode[i]);
        }
-       m_multimode += mMaterial->IdMode+ (mMaterial->ras_mode & ~(COLLIDER|USE_LIGHT));
+       m_multimode += mMaterial->IdMode+ (mMaterial->ras_mode & ~(USE_LIGHT));
 }
 
 KX_BlenderMaterial::~KX_BlenderMaterial()
@@ -231,7 +236,7 @@ void KX_BlenderMaterial::OnExit()
        }
 
        if( mMaterial->tface ) 
-               GPU_set_tpage(mMaterial->tface, 1);
+               GPU_set_tpage(mMaterial->tface, 1, mMaterial->alphablend);
 }
 
 
@@ -247,7 +252,7 @@ void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
                        mLastShader = NULL;
                }
 
-               ras->SetBlendingMode(TF_SOLID);
+               ras->SetAlphaBlend(TF_SOLID);
                BL_Texture::DisableAllTextures();
                return;
        }
@@ -268,11 +273,11 @@ void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
        }
 
        if(!mUserDefBlend) {
-               ras->SetBlendingMode(mMaterial->transp);
+               ras->SetAlphaBlend(mMaterial->alphablend);
        }
        else {
-               ras->SetBlendingMode(TF_SOLID);
-               ras->SetBlendingMode(-1); // indicates custom mode
+               ras->SetAlphaBlend(TF_SOLID);
+               ras->SetAlphaBlend(-1); // indicates custom mode
 
                // tested to be valid enums
                glEnable(GL_BLEND);
@@ -283,7 +288,7 @@ void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
 void KX_BlenderMaterial::setBlenderShaderData( bool enable, RAS_IRasterizer *ras)
 {
        if( !enable || !mBlenderShader->Ok() ) {
-               ras->SetBlendingMode(TF_SOLID);
+               ras->SetAlphaBlend(TF_SOLID);
 
                // frame cleanup.
                if(mLastBlenderShader) {
@@ -297,7 +302,7 @@ void KX_BlenderMaterial::setBlenderShaderData( bool enable, RAS_IRasterizer *ras
        }
 
        if(!mBlenderShader->Equals(mLastBlenderShader)) {
-               ras->SetBlendingMode(mMaterial->transp);
+               ras->SetAlphaBlend(mMaterial->alphablend);
 
                if(mLastBlenderShader)
                        mLastBlenderShader->SetProg(false);
@@ -314,14 +319,14 @@ void KX_BlenderMaterial::setTexData( bool enable, RAS_IRasterizer *ras)
        BL_Texture::DisableAllTextures();
 
        if( !enable ) {
-               ras->SetBlendingMode(TF_SOLID);
+               ras->SetAlphaBlend(TF_SOLID);
                return;
        }
 
        BL_Texture::ActivateFirst();
 
        if( mMaterial->IdMode == DEFAULT_BLENDER ) {
-               ras->SetBlendingMode(mMaterial->transp);
+               ras->SetAlphaBlend(mMaterial->alphablend);
                return;
        }
 
@@ -331,7 +336,7 @@ void KX_BlenderMaterial::setTexData( bool enable, RAS_IRasterizer *ras)
                        mTextures[0].ActivateTexture();
                        mTextures[0].setTexEnv(0, true);
                        mTextures[0].SetMapping(mMaterial->mapping[0].mapping);
-                       ras->SetBlendingMode(mMaterial->transp);
+                       ras->SetAlphaBlend(mMaterial->alphablend);
                }
                return;
        }
@@ -354,11 +359,11 @@ void KX_BlenderMaterial::setTexData( bool enable, RAS_IRasterizer *ras)
        }
 
        if(!mUserDefBlend) {
-               ras->SetBlendingMode(mMaterial->transp);
+               ras->SetAlphaBlend(mMaterial->alphablend);
        }
        else {
-               ras->SetBlendingMode(TF_SOLID);
-               ras->SetBlendingMode(-1); // indicates custom mode
+               ras->SetAlphaBlend(TF_SOLID);
+               ras->SetAlphaBlend(-1); // indicates custom mode
 
                glEnable(GL_BLEND);
                glBlendFunc(mBlendFunc[0], mBlendFunc[1]);
@@ -393,15 +398,15 @@ KX_BlenderMaterial::ActivatShaders(
                else
                        tmp->setShaderData(false, rasty);
 
-               if(mMaterial->mode & RAS_IRasterizer::KX_TWOSIDE)
+               if (mMaterial->ras_mode &TWOSIDED)
                        rasty->SetCullFace(false);
                else
                        rasty->SetCullFace(true);
 
-               if (((mMaterial->ras_mode &WIRE)!=0) || (mMaterial->mode & RAS_IRasterizer::KX_LINES) ||
+               if ((mMaterial->ras_mode &WIRE) ||
                    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
                {               
-                       if((mMaterial->ras_mode &WIRE)!=0
+                       if (mMaterial->ras_mode &WIRE
                                rasty->SetCullFace(false);
                        rasty->SetLines(true);
                }
@@ -438,15 +443,15 @@ KX_BlenderMaterial::ActivateBlenderShaders(
                else
                        tmp->setBlenderShaderData(false, rasty);
 
-               if(mMaterial->mode & RAS_IRasterizer::KX_TWOSIDE)
+               if (mMaterial->ras_mode &TWOSIDED)
                        rasty->SetCullFace(false);
                else
                        rasty->SetCullFace(true);
 
-               if (((mMaterial->ras_mode & WIRE)!=0) || (mMaterial->mode & RAS_IRasterizer::KX_LINES) ||
+               if ((mMaterial->ras_mode &WIRE) ||
                    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
                {               
-                       if((mMaterial->ras_mode &WIRE)!=0
+                       if (mMaterial->ras_mode &WIRE
                                rasty->SetCullFace(false);
                        rasty->SetLines(true);
                }
@@ -487,15 +492,15 @@ KX_BlenderMaterial::ActivateMat(
                else
                        tmp->setTexData( false,rasty);
 
-               if(mMaterial->mode & RAS_IRasterizer::KX_TWOSIDE)
+               if (mMaterial->ras_mode &TWOSIDED)
                        rasty->SetCullFace(false);
                else
                        rasty->SetCullFace(true);
 
-               if (((mMaterial->ras_mode &WIRE)!=0) || (mMaterial->mode & RAS_IRasterizer::KX_LINES) ||
+               if ((mMaterial->ras_mode &WIRE) ||
                    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
                {               
-                       if((mMaterial->ras_mode &WIRE)!=0
+                       if (mMaterial->ras_mode &WIRE
                                rasty->SetCullFace(false);
                        rasty->SetLines(true);
                }
@@ -570,17 +575,17 @@ void KX_BlenderMaterial::ActivateMeshSlot(const RAS_MeshSlot & ms, RAS_IRasteriz
                mShader->Update(ms, rasty);
        }
        else if(mBlenderShader && GLEW_ARB_shader_objects) {
-               int blendmode;
+               int alphablend;
 
                mBlenderShader->Update(ms, rasty);
 
                /* we do blend modes here, because they can change per object
                 * with the same material due to obcolor/obalpha */
-               blendmode = mBlenderShader->GetBlendMode();
-               if((blendmode == TF_SOLID || blendmode == TF_ALPHA) && mMaterial->transp != TF_SOLID)
-                       blendmode = mMaterial->transp;
+               alphablend = mBlenderShader->GetAlphaBlend();
+               if(ELEM3(alphablend, GEMAT_SOLID, GEMAT_ALPHA, GEMAT_ALPHA_SORT) && mMaterial->alphablend != GEMAT_SOLID)
+                       alphablend = mMaterial->alphablend;
 
-               rasty->SetBlendingMode(blendmode);
+               rasty->SetAlphaBlend(alphablend);
        }
 }
 
index 766e20be8257fd39756ec2b6b49335732091c86e..236bd6afdc85545d380317de27bea9b10722fa72 100644 (file)
@@ -38,7 +38,8 @@ public:
        KX_BlenderMaterial();
        void Initialize(
                class KX_Scene* scene,
-               BL_Material*    mat
+               BL_Material*    mat,
+               GameSettings*   game
        );
 
        virtual ~KX_BlenderMaterial();
index d32f267f0e043334981edeb9658f55be35730638..098c136bfa3ef6f1a6fb9f0045694d900f861c31 100644 (file)
@@ -78,10 +78,10 @@ void KX_PolygonMaterial::Initialize(
                int tile,
                int tilexrep,
                int tileyrep,
-               int mode,
-               int transp,
+               int alphablend,
                bool alpha,
                bool zsort,
+               bool light,
                int lightlayer,
                struct MTFace* tface,
                unsigned int* mcol)
@@ -93,10 +93,12 @@ void KX_PolygonMaterial::Initialize(
                                                        tile,
                                                        tilexrep,
                                                        tileyrep,
-                                                       mode,
-                                                       transp,
+                                                       alphablend,
                                                        alpha,
-                                                       zsort);
+                                                       zsort,
+                                                       light,
+                                                       (texname && texname != ""?true:false), /* if we have a texture we have image */
+                                                       ma?&ma->game:NULL);
        m_tface = tface;
        m_mcol = mcol;
        m_material = ma;
@@ -168,7 +170,7 @@ void KX_PolygonMaterial::DefaultActivate(RAS_IRasterizer* rasty, TCachingInfo& c
        if (GetCachingInfo() != cachingInfo)
        {
                if (!cachingInfo)
-                       GPU_set_tpage(NULL, 0);
+                       GPU_set_tpage(NULL, 0, 0);
 
                cachingInfo = GetCachingInfo();
 
@@ -176,15 +178,15 @@ void KX_PolygonMaterial::DefaultActivate(RAS_IRasterizer* rasty, TCachingInfo& c
                {
                        Image *ima = (Image*)m_tface->tpage;
                        GPU_update_image_time(ima, rasty->GetTime());
-                       GPU_set_tpage(m_tface, 1);
+                       GPU_set_tpage(m_tface, 1, m_alphablend);
                }
                else
-                       GPU_set_tpage(NULL, 0);
+                       GPU_set_tpage(NULL, 0, 0);
                
-               if(m_drawingmode & RAS_IRasterizer::KX_TWOSIDE)
-                       rasty->SetCullFace(false);
-               else
+               if(m_drawingmode & RAS_IRasterizer::KX_BACKCULL)
                        rasty->SetCullFace(true);
+               else
+                       rasty->SetCullFace(false);
 
                if ((m_drawingmode & RAS_IRasterizer::KX_LINES) ||
                        (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
@@ -318,7 +320,7 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, setTexture, "setTexture(tface)")
        if (PyArg_ParseTuple(args, "O!:setTexture", &PyCapsule_Type, &pytface))
        {
                MTFace *tface = (MTFace*) PyCapsule_GetPointer(pytface, KX_POLYGONMATERIAL_CAPSULE_ID);
-               GPU_set_tpage(tface, 1);
+               GPU_set_tpage(tface, 1, m_alphablend);
                Py_RETURN_NONE;
        }
        
index 3520995def363345a3e2172760d5b53272af2a43..b09ddd39141460580645f7b52d1ddca3d5c1f34e 100644 (file)
@@ -78,10 +78,10 @@ public:
                int tile,
                int tilexrep,
                int tileyrep,
-               int mode,
-               int transp,
+               int alphablend,
                bool alpha,
                bool zsort,
+               bool light,
                int lightlayer,
                struct MTFace* tface,
                unsigned int* mcol);
index 5a1b52489b436e7865add869fb77a51473e6ffd7..9948f48d7f3ca87f76dede8606f29245bd92a0f4 100644 (file)
@@ -36,6 +36,7 @@
 
 #include "DNA_image_types.h"
 #include "DNA_meshdata_types.h"
+#include "DNA_material_types.h"
 
 void  RAS_IPolyMaterial::Initialize( 
                                const STR_String& texname,
@@ -44,10 +45,12 @@ void  RAS_IPolyMaterial::Initialize(
                                int tile,
                                int tilexrep,
                                int tileyrep,
-                               int mode,
-                               int transp,
+                               int alphablend,
                                bool alpha,
-                               bool zsort)
+                               bool zsort,
+                               bool light,
+                               bool image,
+                               struct GameSettings* game)
 {
        m_texturename = texname;
        m_materialname = matname;
@@ -55,10 +58,10 @@ void  RAS_IPolyMaterial::Initialize(
        m_tile = tile;
        m_tilexrep = tilexrep;
        m_tileyrep = tileyrep;
-       m_drawingmode = mode;
-       m_transp = transp;
+       m_alphablend = alphablend;
        m_alpha = alpha;
        m_zsort = zsort;
+       m_light = light;
        m_polymatid = m_newpolymatid++;
        m_flag = 0;
        m_multimode = 0;
@@ -66,6 +69,7 @@ void  RAS_IPolyMaterial::Initialize(
        m_specular.setValue(0.5,0.5,0.5);
        m_specularity = 1.0;
        m_diffuse.setValue(0.5,0.5,0.5);
+       m_drawingmode = ConvertFaceMode(game, image);
 }
 
 RAS_IPolyMaterial::RAS_IPolyMaterial() 
@@ -75,9 +79,10 @@ RAS_IPolyMaterial::RAS_IPolyMaterial()
                m_tilexrep(0),
                m_tileyrep(0),
                m_drawingmode (0),
-               m_transp(0),
+               m_alphablend(0),
                m_alpha(false),
                m_zsort(false),
+               m_light(false),
                m_materialindex(0),
                m_polymatid(0),
                m_flag(0),
@@ -95,8 +100,7 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname,
                                                                         int tile,
                                                                         int tilexrep,
                                                                         int tileyrep,
-                                                                        int mode,
-                                                                        int transp,
+                                                                        int alphablend,
                                                                         bool alpha,
                                                                         bool zsort)
                : m_texturename(texname),
@@ -104,8 +108,7 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname,
                m_tile(tile),
                m_tilexrep(tilexrep),
                m_tileyrep(tileyrep),
-               m_drawingmode (mode),
-               m_transp(transp),
+               m_alphablend(alphablend),
                m_alpha(alpha),
                m_zsort(zsort),
                m_materialindex(materialindex),
@@ -128,9 +131,9 @@ bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const
                        this->m_multimode                       ==              lhs.m_multimode &&
                        this->m_flag                            ==              lhs.m_flag              &&
                        this->m_drawingmode                     ==              lhs.m_drawingmode &&
-                       this->m_transp                          ==              lhs.m_transp &&
-                       this->m_texturename.hash()      ==              lhs.m_texturename.hash() &&
-                       this->m_materialname.hash() ==          lhs.m_materialname.hash()
+                       this->m_alphablend                      ==              lhs.m_alphablend &&
+                       this->m_texturename.hash()              ==              lhs.m_texturename.hash() &&
+                       this->m_materialname.hash()             ==              lhs.m_materialname.hash()
                );
 
                return test;
@@ -141,9 +144,10 @@ bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const
                                this->m_tile            ==              lhs.m_tile &&
                                this->m_tilexrep        ==              lhs.m_tilexrep &&
                                this->m_tileyrep        ==              lhs.m_tileyrep &&
-                               this->m_transp          ==              lhs.m_transp &&
+                               this->m_alphablend      ==              lhs.m_alphablend &&
                                this->m_alpha           ==              lhs.m_alpha &&
                                this->m_zsort           ==              lhs.m_zsort &&
+                               this->m_light           ==              lhs.m_light &&
                                this->m_drawingmode     ==              lhs.m_drawingmode &&
                                this->m_texturename.hash()      ==              lhs.m_texturename.hash() &&
                                this->m_materialname.hash() ==          lhs.m_materialname.hash()
@@ -151,6 +155,21 @@ bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const
        }
 }
 
+int RAS_IPolyMaterial::ConvertFaceMode(struct GameSettings *game, bool image) const
+{
+       if (!game) return (image?GEMAT_TEX:0);
+
+       int modefinal = 0;
+
+       int orimode   = game->face_orientation;
+       int alpha_blend = game->alpha_blend;
+       int flags = game->flag & (GEMAT_TEXT | GEMAT_BACKCULL);
+
+       modefinal = orimode | alpha_blend | flags;
+       modefinal |= (image ? GEMAT_TEX : 0);
+
+       return modefinal;
+}
 
 void RAS_IPolyMaterial::GetMaterialRGBAColor(unsigned char *rgba) const
 {
@@ -241,7 +260,7 @@ bool RAS_IPolyMaterial::UsesLighting(RAS_IRasterizer *rasty) const
        else if(rasty->GetDrawingMode() < RAS_IRasterizer::KX_SOLID);
        else if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_SHADOW);
        else
-               dolights = (m_drawingmode & RAS_IRasterizer::KX_LIGHT)!=0;
+               dolights = m_light;
        
        return dolights;
 }
index 2a5c6a179b61d41b02e51d2dfdff38090c93d025..69d07713c49044a2d27b2b645a09ef392f91110c 100644 (file)
@@ -49,6 +49,7 @@ struct Material;
 struct Image;
 struct Scene;
 class SCA_IScene;
+struct GameSettings;
 
 enum MaterialProps
 {
@@ -78,10 +79,11 @@ protected:
        STR_HashedString                m_materialname; //also needed for touchsensor  
        int                                             m_tile;
        int                                             m_tilexrep,m_tileyrep;
-       int                                             m_drawingmode;  // tface->mode
-       int                                             m_transp;
+       int                                             m_drawingmode;
+       int                                             m_alphablend;
        bool                                    m_alpha;
        bool                                    m_zsort;
+       bool                                    m_light;
        int                                             m_materialindex;
        
        unsigned int                    m_polymatid;
@@ -102,9 +104,9 @@ public:
        // care! these are taken from blender polygonflags, see file DNA_mesh_types.h for #define TF_BILLBOARD etc.
        enum MaterialFlags
        {
-               BILLBOARD_SCREENALIGNED = 256,
-               BILLBOARD_AXISALIGNED = 4096,
-               SHADOW                            =8192
+               BILLBOARD_SCREENALIGNED = 512,  /* GEMAT_HALO */
+               BILLBOARD_AXISALIGNED   = 1024, /* GEMAT_BILLBOARD */
+               SHADOW                  =2048   /* GEMAT_SHADOW */
        };
 
        RAS_IPolyMaterial();
@@ -114,7 +116,6 @@ public:
                                          int tile,
                                          int tilexrep,
                                          int tileyrep,
-                                         int mode,
                                          int transp,
                                          bool alpha,
                                          bool zsort);
@@ -124,10 +125,13 @@ public:
                                        int tile,
                                        int tilexrep,
                                        int tileyrep,
-                                       int mode,
                                        int transp,
                                        bool alpha,
-                                       bool zsort);
+                                       bool zsort,
+                                       bool light,
+                                       bool image,
+                                       struct GameSettings* game);
+
        virtual ~RAS_IPolyMaterial() {};
  
        /**
@@ -174,6 +178,11 @@ public:
 
        virtual void            Replace_IScene(SCA_IScene *val) {}; /* overridden by KX_BlenderMaterial */
 
+       /**
+       * @return the equivalent drawing mode for the material settings (equivalent to old TexFace tface->mode).
+       */
+       int                                     ConvertFaceMode(struct GameSettings *game, bool image) const;
+
        /*
         * PreCalculate texture gen
         */
index 877a7219a1c3a82903e8724da9b3e70d4f01508d..2988aa4effb8cd203c9008e18d03611ca3991161 100644 (file)
@@ -68,11 +68,7 @@ class RAS_IRasterizer
 public:
        RAS_IRasterizer(RAS_ICanvas* canv){};
        virtual ~RAS_IRasterizer(){};
-       /**
-        */
-       enum    {
-                       RAS_RENDER_3DPOLYGON_TEXT = 16384       /* TF_BMFONT */
-       };
+
        /**
         * Drawing types
         */
@@ -106,9 +102,9 @@ public:
        /**
         */
        enum    {        
-                       KX_TEX = 4,                     /* TF_TEX */
-                       KX_LIGHT = 16,          /* TF_LIGHT */
-                       KX_TWOSIDE = 512,       /* TF_TWOSIDE */
+                       RAS_RENDER_3DPOLYGON_TEXT = 64, /* GEMAT_TEXT */
+                       KX_BACKCULL = 16,               /* GEMAT_BACKCULL */
+                       KX_TEX = 4096,                  /* GEMAT_TEX */
                        KX_LINES = 32768         
        };
 
@@ -417,7 +413,7 @@ public:
        virtual int             GetMotionBlurState()=0;
        virtual void    SetMotionBlurState(int newstate)=0;
 
-       virtual void    SetBlendingMode(int blendmode)=0;
+       virtual void    SetAlphaBlend(int alphablend)=0;
        virtual void    SetFrontFace(bool ccw)=0;
 
        virtual void    SetAnisotropicFiltering(short level)=0;
index 6ad9e59147476f3c126b24ad0866e9aea5f87056..d9039a2a68d734472db1ed41fd78d0d11cb37ee0 100644 (file)
@@ -89,7 +89,7 @@ RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas)
        m_motionblurvalue(-1.0),
        m_texco_num(0),
        m_attrib_num(0),
-       //m_last_blendmode(GPU_BLEND_SOLID),
+       //m_last_alphablend(GPU_BLEND_SOLID),
        m_last_frontface(true),
        m_materialCachingInfo(0)
 {
@@ -126,8 +126,8 @@ bool RAS_OpenGLRasterizer::Init()
 
        glDisable(GL_BLEND);
        glDisable(GL_ALPHA_TEST);
-       //m_last_blendmode = GPU_BLEND_SOLID;
-       GPU_set_material_blend_mode(GPU_BLEND_SOLID);
+       //m_last_alphablend = GPU_BLEND_SOLID;
+       GPU_set_material_alpha_blend(GPU_BLEND_SOLID);
 
        glFrontFace(GL_CCW);
        m_last_frontface = true;
@@ -303,8 +303,8 @@ bool RAS_OpenGLRasterizer::BeginFrame(int drawingmode, double time)
 
        glDisable(GL_BLEND);
        glDisable(GL_ALPHA_TEST);
-       //m_last_blendmode = GPU_BLEND_SOLID;
-       GPU_set_material_blend_mode(GPU_BLEND_SOLID);
+       //m_last_alphablend = GPU_BLEND_SOLID;
+       GPU_set_material_alpha_blend(GPU_BLEND_SOLID);
 
        glFrontFace(GL_CCW);
        m_last_frontface = true;
@@ -873,10 +873,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi)
                // MCol *mcol = (MCol*)ms.m_pDerivedMesh->getFaceDataArray(ms.m_pDerivedMesh, CD_MCOL); /* UNUSED */
 
                // handle two-side
-               if (current_polymat->GetDrawingMode() & RAS_IRasterizer::KX_TWOSIDE)
-                       this->SetCullFace(false);
-               else
+               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, 
@@ -890,9 +890,9 @@ void RAS_OpenGLRasterizer::IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi)
                        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_blend_mode();
+                       int current_blend_mode = GPU_get_material_alpha_blend();
                        ms.m_pDerivedMesh->drawFacesGLSL(ms.m_pDerivedMesh, CheckMaterialDM);
-                       GPU_set_material_blend_mode(current_blend_mode);
+                       GPU_set_material_alpha_blend(current_blend_mode);
                } else {
                        //ms.m_pDerivedMesh->drawMappedFacesTex(ms.m_pDerivedMesh, CheckTexfaceDM, mcol);
                        current_blmat_nr = current_polymat->GetMaterialIndex();
@@ -1204,36 +1204,36 @@ void RAS_OpenGLRasterizer::DisableMotionBlur()
        m_motionblurvalue = -1.0;
 }
 
-void RAS_OpenGLRasterizer::SetBlendingMode(int blendmode)
+void RAS_OpenGLRasterizer::SetAlphaBlend(int alphablend)
 {
-       GPU_set_material_blend_mode(blendmode);
+       GPU_set_material_alpha_blend(alphablend);
 /*
-       if(blendmode == m_last_blendmode)
+       if(alphablend == m_last_alphablend)
                return;
 
-       if(blendmode == GPU_BLEND_SOLID) {
+       if(alphablend == GPU_BLEND_SOLID) {
                glDisable(GL_BLEND);
                glDisable(GL_ALPHA_TEST);
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        }
-       else if(blendmode == GPU_BLEND_ADD) {
+       else if(alphablend == GPU_BLEND_ADD) {
                glBlendFunc(GL_ONE, GL_ONE);
                glEnable(GL_BLEND);
                glDisable(GL_ALPHA_TEST);
        }
-       else if(blendmode == GPU_BLEND_ALPHA) {
+       else if(alphablend == GPU_BLEND_ALPHA) {
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                glEnable(GL_ALPHA_TEST);
                glAlphaFunc(GL_GREATER, 0.0f);
        }
-       else if(blendmode == GPU_BLEND_CLIP) {
+       else if(alphablend == GPU_BLEND_CLIP) {
                glDisable(GL_BLEND); 
                glEnable(GL_ALPHA_TEST);
                glAlphaFunc(GL_GREATER, 0.5f);
        }
 
-       m_last_blendmode = blendmode;
+       m_last_alphablend = alphablend;
 */
 }
 
index c0e02f6df77043c7893c215bf49befd3f341cc8b..cbfa49510a58072cf6471d5cfb520ae0ac2b2745 100644 (file)
@@ -111,7 +111,7 @@ protected:
        TexCoGen                m_attrib[RAS_MAX_ATTRIB];
        int                             m_texco_num;
        int                             m_attrib_num;
-       //int                           m_last_blendmode;
+       //int                           m_last_alphablend;
        bool                    m_last_frontface;
 
        /** Stores the caching information for the last material activated. */
@@ -312,7 +312,7 @@ public:
                        m_motionblur = newstate;
        };
 
-       virtual void    SetBlendingMode(int blendmode);
+       virtual void    SetAlphaBlend(int alphablend);
        virtual void    SetFrontFace(bool ccw);
        
        virtual void    SetAnisotropicFiltering(short level);