Texturing: texture and 3d view draw type changes, these should only have any

effect for a render engine using new shading nodes. In short:

* No longer uses images assigned to faces in the uv layer, rather the active
  image texture node is what is edited/painted/drawn.
* Textured draw type now shows the active image texture node, with solid
  lighting.
* Material draw mode shows GLSL shader of a simplified material node tree,
  using solid lighting.
* Textures for modifiers, brushes, etc, are now available from a dropdown in
  the texture tab in the properties editor. These do not use new shading nodes
  yet.

http://wiki.blender.org/index.php/Dev:2.6/Source/Render/TextureWorkflow

6 files changed, 378 insertions, 0 deletions

diff --git a/source/blender/blenkernel/BKE_DerivedMesh.h b/source/blender/blenkernel/BKE_DerivedMesh.h
index 5e403849289..0c5dc32f6d8 100644
--- a/source/blender/blenkernel/BKE_DerivedMesh.h
+++ b/source/blender/blenkernel/BKE_DerivedMesh.h
@@ -324,6 +324,14 @@ struct DerivedMesh {
 															   float t),
 								  void *userData);
 
+	/* Draw all faces with materials
+	 *  o setMaterial is called for every different material nr
+	 *  o setFace is called to verify if a face must be hidden
+	 */
+	void (*drawMappedFacesMat)(DerivedMesh *dm,
+		void (*setMaterial)(void *userData, int, void *attribs),
+		int (*setFace)(void *userData, int index), void *userData);
+
 	/* Release reference to the DerivedMesh. This function decides internally
 	 * if the DerivedMesh will be freed, or cached for later use. */
 	void (*release)(DerivedMesh *dm);
diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h
index a06d57ae517..580f78d3063 100644
--- a/source/blender/blenkernel/BKE_node.h
+++ b/source/blender/blenkernel/BKE_node.h
@@ -351,6 +351,7 @@ struct bNode	*nodeGetActive(struct bNodeTree *ntree);
 struct bNode	*nodeGetActiveID(struct bNodeTree *ntree, short idtype);
 int				nodeSetActiveID(struct bNodeTree *ntree, short idtype, struct ID *id);
 void			nodeClearActiveID(struct bNodeTree *ntree, short idtype);
+struct bNode	*nodeGetActiveTexture(struct bNodeTree *ntree);
 
 void			nodeUpdate(struct bNodeTree *ntree, struct bNode *node);
 int				nodeUpdateID(struct bNodeTree *ntree, struct ID *id);
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index aaed0381b2e..ecabd1a79bc 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -1123,6 +1123,140 @@ static void emDM_drawFacesGLSL(DerivedMesh *dm,
 	dm->drawMappedFacesGLSL(dm, setMaterial, NULL, NULL);
 }
 
+static void emDM_drawMappedFacesMat(DerivedMesh *dm,
+			   void (*setMaterial)(void *userData, int, void *attribs),
+			   int (*setFace)(void *userData, int index), void *userData) 
+{
+	EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
+	EditMesh *em= emdm->em;
+	float (*vertexCos)[3]= emdm->vertexCos;
+	float (*vertexNos)[3]= emdm->vertexNos;
+	EditVert *eve;
+	EditFace *efa;
+	DMVertexAttribs attribs= {{{0}}};
+	GPUVertexAttribs gattribs;
+	int i, b, matnr, new_matnr;
+
+	matnr = -1;
+
+	/* always use smooth shading even for flat faces, else vertex colors wont interpolate */
+	glShadeModel(GL_SMOOTH);
+
+	for (i=0,eve=em->verts.first; eve; eve= eve->next)
+		eve->tmp.l = (intptr_t) i++;
+
+#define PASSATTRIB(efa, eve, vert) {											\
+	if(attribs.totorco) {														\
+		float *orco = attribs.orco.array[eve->tmp.l];							\
+		if(attribs.orco.glTexco)												\
+			glTexCoord3fv(orco);												\
+		else																	\
+			glVertexAttrib3fvARB(attribs.orco.glIndex, orco);					\
+	}																			\
+	for(b = 0; b < attribs.tottface; b++) {										\
+		MTFace *_tf = (MTFace*)((char*)efa->data + attribs.tface[b].emOffset);	\
+		if(attribs.tface[b].glTexco)											\
+			glTexCoord2fv(_tf->uv[vert]);										\
+		else																	\
+			glVertexAttrib2fvARB(attribs.tface[b].glIndex, _tf->uv[vert]);		\
+	}																			\
+	for(b = 0; b < attribs.totmcol; b++) {										\
+		MCol *cp = (MCol*)((char*)efa->data + attribs.mcol[b].emOffset);		\
+		GLubyte col[4];															\
+		col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a;				\
+		glVertexAttrib4ubvARB(attribs.mcol[b].glIndex, col);					\
+	}																			\
+	if(attribs.tottang) {														\
+		float *tang = attribs.tang.array[i*4 + vert];							\
+		glVertexAttrib4fvARB(attribs.tang.glIndex, tang);						\
+	}																			\
+}
+
+	for (i=0,efa= em->faces.first; efa; i++,efa= efa->next) {
+		int drawSmooth= (efa->flag & ME_SMOOTH);
+
+		/* face hiding */
+		if(setFace && !setFace(userData, i))
+			continue;
+
+		/* material */
+		new_matnr = efa->mat_nr + 1;
+		if(new_matnr != matnr) {
+			setMaterial(userData, matnr = new_matnr, &gattribs);
+			DM_vertex_attributes_from_gpu(dm, &gattribs, &attribs);
+		}
+
+		/* face */
+		glBegin(efa->v4?GL_QUADS:GL_TRIANGLES);
+		if (!drawSmooth) {
+			if(vertexCos) glNormal3fv(emdm->faceNos[i]);
+			else glNormal3fv(efa->n);
+
+			PASSATTRIB(efa, efa->v1, 0);
+			if(vertexCos) glVertex3fv(vertexCos[(int) efa->v1->tmp.l]);
+			else glVertex3fv(efa->v1->co);
+
+			PASSATTRIB(efa, efa->v2, 1);
+			if(vertexCos) glVertex3fv(vertexCos[(int) efa->v2->tmp.l]);
+			else glVertex3fv(efa->v2->co);
+
+			PASSATTRIB(efa, efa->v3, 2);
+			if(vertexCos) glVertex3fv(vertexCos[(int) efa->v3->tmp.l]);
+			else glVertex3fv(efa->v3->co);
+
+			if(efa->v4) {
+				PASSATTRIB(efa, efa->v4, 3);
+				if(vertexCos) glVertex3fv(vertexCos[(int) efa->v4->tmp.l]);
+				else glVertex3fv(efa->v4->co);
+			}
+		} else {
+			PASSATTRIB(efa, efa->v1, 0);
+			if(vertexCos) {
+				glNormal3fv(vertexNos[(int) efa->v1->tmp.l]);
+				glVertex3fv(vertexCos[(int) efa->v1->tmp.l]);
+			}
+			else {
+				glNormal3fv(efa->v1->no);
+				glVertex3fv(efa->v1->co);
+			}
+
+			PASSATTRIB(efa, efa->v2, 1);
+			if(vertexCos) {
+				glNormal3fv(vertexNos[(int) efa->v2->tmp.l]);
+				glVertex3fv(vertexCos[(int) efa->v2->tmp.l]);
+			}
+			else {
+				glNormal3fv(efa->v2->no);
+				glVertex3fv(efa->v2->co);
+			}
+
+			PASSATTRIB(efa, efa->v3, 2);
+			if(vertexCos) {
+				glNormal3fv(vertexNos[(int) efa->v3->tmp.l]);
+				glVertex3fv(vertexCos[(int) efa->v3->tmp.l]);
+			}
+			else {
+				glNormal3fv(efa->v3->no);
+				glVertex3fv(efa->v3->co);
+			}
+
+			if(efa->v4) {
+				PASSATTRIB(efa, efa->v4, 3);
+				if(vertexCos) {
+					glNormal3fv(vertexNos[(int) efa->v4->tmp.l]);
+					glVertex3fv(vertexCos[(int) efa->v4->tmp.l]);
+				}
+				else {
+					glNormal3fv(efa->v4->no);
+					glVertex3fv(efa->v4->co);
+				}
+			}
+		}
+		glEnd();
+	}
+#undef PASSATTRIB
+}
+
 static void emDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
 {
 	EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
@@ -1429,6 +1563,7 @@ DerivedMesh *editmesh_get_derived(EditMesh *em, float (*vertexCos)[3])
 	emdm->dm.drawMappedFacesGLSL = emDM_drawMappedFacesGLSL;
 	emdm->dm.drawFacesTex = emDM_drawFacesTex;
 	emdm->dm.drawFacesGLSL = emDM_drawFacesGLSL;
+	emdm->dm.drawMappedFacesMat = emDM_drawMappedFacesMat;
 	emdm->dm.drawUVEdges = emDM_drawUVEdges;
 
 	emdm->dm.release = emDM_release;
diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index d2c86a14572..5ebdd1ec547 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -1351,6 +1351,85 @@ static void cdDM_drawFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, void *at
 	dm->drawMappedFacesGLSL(dm, setMaterial, NULL, NULL);
 }
 
+static void cdDM_drawMappedFacesMat(DerivedMesh *dm,
+	void (*setMaterial)(void *userData, int, void *attribs),
+	int (*setFace)(void *userData, int index), void *userData)
+{
+	CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
+	GPUVertexAttribs gattribs;
+	DMVertexAttribs attribs;
+	MVert *mvert = cddm->mvert;
+	MFace *mf = cddm->mface;
+	float (*nors)[3] = dm->getFaceDataArray(dm, CD_NORMAL);
+	int a, matnr, new_matnr;
+	int orig, *index = dm->getFaceDataArray(dm, CD_ORIGINDEX);
+
+	cdDM_update_normals_from_pbvh(dm);
+
+	matnr = -1;
+
+	glShadeModel(GL_SMOOTH);
+
+	memset(&attribs, 0, sizeof(attribs));
+
+	glBegin(GL_QUADS);
+
+	for(a = 0; a < dm->numFaceData; a++, mf++) {
+		const int smoothnormal = (mf->flag & ME_SMOOTH);
+
+		/* material */
+		new_matnr = mf->mat_nr + 1;
+
+		if(new_matnr != matnr) {
+			glEnd();
+
+			setMaterial(userData, matnr = new_matnr, &gattribs);
+			DM_vertex_attributes_from_gpu(dm, &gattribs, &attribs);
+
+			glBegin(GL_QUADS);
+		}
+
+		/* skipping faces */
+		if(setFace) {
+			orig = (index)? index[a]: a;
+
+			if(orig != ORIGINDEX_NONE && !setFace(userData, orig))
+				continue;
+		}
+
+		/* smooth normal */
+		if(!smoothnormal) {
+			if(nors) {
+				glNormal3fv(nors[a]);
+			}
+			else {
+				/* TODO ideally a normal layer should always be available */
+				float nor[3];
+
+				if(mf->v4)
+					normal_quad_v3( nor,mvert[mf->v1].co, mvert[mf->v2].co, mvert[mf->v3].co, mvert[mf->v4].co);
+				else
+					normal_tri_v3( nor,mvert[mf->v1].co, mvert[mf->v2].co, mvert[mf->v3].co);
+
+				glNormal3fv(nor);
+			}
+		}
+
+		/* vertices */
+		cddm_draw_attrib_vertex(&attribs, mvert, a, mf->v1, 0, smoothnormal);
+		cddm_draw_attrib_vertex(&attribs, mvert, a, mf->v2, 1, smoothnormal);
+		cddm_draw_attrib_vertex(&attribs, mvert, a, mf->v3, 2, smoothnormal);
+
+		if(mf->v4)
+			cddm_draw_attrib_vertex(&attribs, mvert, a, mf->v4, 3, smoothnormal);
+		else
+			cddm_draw_attrib_vertex(&attribs, mvert, a, mf->v3, 2, smoothnormal);
+	}
+	glEnd();
+
+	glShadeModel(GL_FLAT);
+}
+
 static void cdDM_drawMappedEdges(DerivedMesh *dm, int (*setDrawOptions)(void *userData, int index), void *userData)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
@@ -1521,6 +1600,7 @@ static CDDerivedMesh *cdDM_create(const char *desc)
 	dm->drawMappedFaces = cdDM_drawMappedFaces;
 	dm->drawMappedFacesTex = cdDM_drawMappedFacesTex;
 	dm->drawMappedFacesGLSL = cdDM_drawMappedFacesGLSL;
+	dm->drawMappedFacesMat = cdDM_drawMappedFacesMat;
 
 	dm->foreachMappedVert = cdDM_foreachMappedVert;
 	dm->foreachMappedEdge = cdDM_foreachMappedEdge;
diff --git a/source/blender/blenkernel/intern/node.c b/source/blender/blenkernel/intern/node.c
index 9fc18c3e0fc..fa023d8fb43 100644
--- a/source/blender/blenkernel/intern/node.c
+++ b/source/blender/blenkernel/intern/node.c
@@ -1314,11 +1314,15 @@ void nodeSetActive(bNodeTree *ntree, bNode *node)
 			if(GS(node->id->name) == GS(tnode->id->name))
 				tnode->flag &= ~NODE_ACTIVE_ID;
 		}
+		if(node->typeinfo->nclass == NODE_CLASS_TEXTURE)
+			tnode->flag &= ~NODE_ACTIVE_TEXTURE;
 	}
 	
 	node->flag |= NODE_ACTIVE;
 	if(node->id)
 		node->flag |= NODE_ACTIVE_ID;
+	if(node->typeinfo->nclass == NODE_CLASS_TEXTURE)
+		node->flag |= NODE_ACTIVE_TEXTURE;
 }
 
 /* use flags are not persistent yet, groups might need different tagging, so we do it each time
diff --git a/source/blender/blenkernel/intern/subsurf_ccg.c b/source/blender/blenkernel/intern/subsurf_ccg.c
index 9848b27d32e..da2245f8401 100644
--- a/source/blender/blenkernel/intern/subsurf_ccg.c
+++ b/source/blender/blenkernel/intern/subsurf_ccg.c
@@ -1511,6 +1511,155 @@ static void ccgDM_drawFacesGLSL(DerivedMesh *dm, int (*setMaterial)(int, void *a
 	dm->drawMappedFacesGLSL(dm, setMaterial, NULL, NULL);
 }
 
+	/* Only used by non-editmesh types */
+static void ccgDM_drawMappedFacesMat(DerivedMesh *dm, void (*setMaterial)(void *userData, int, void *attribs), int (*setFace)(void *userData, int index), void *userData) {
+	CCGDerivedMesh *ccgdm = (CCGDerivedMesh*) dm;
+	CCGSubSurf *ss = ccgdm->ss;
+	CCGFaceIterator *fi = ccgSubSurf_getFaceIterator(ss);
+	GPUVertexAttribs gattribs;
+	DMVertexAttribs attribs= {{{NULL}}};
+	int gridSize = ccgSubSurf_getGridSize(ss);
+	int gridFaces = gridSize - 1;
+	int edgeSize = ccgSubSurf_getEdgeSize(ss);
+	char *faceFlags = ccgdm->faceFlags;
+	int a, b, i, numVerts, matnr, new_matnr, totface;
+
+	ccgdm_pbvh_update(ccgdm);
+
+	matnr = -1;
+
+#define PASSATTRIB(dx, dy, vert) {												\
+	if(attribs.totorco) {														\
+		index = getFaceIndex(ss, f, S, x+dx, y+dy, edgeSize, gridSize); 		\
+		if(attribs.orco.glTexco)												\
+			glTexCoord3fv(attribs.orco.array[index]);							\
+		else																	\
+			glVertexAttrib3fvARB(attribs.orco.glIndex, attribs.orco.array[index]);	\
+	}																			\
+	for(b = 0; b < attribs.tottface; b++) {										\
+		MTFace *tf = &attribs.tface[b].array[a];								\
+		if(attribs.tface[b].glTexco)											\
+			glTexCoord2fv(tf->uv[vert]);										\
+		else																	\
+			glVertexAttrib2fvARB(attribs.tface[b].glIndex, tf->uv[vert]);		\
+	}																			\
+	for(b = 0; b < attribs.totmcol; b++) {										\
+		MCol *cp = &attribs.mcol[b].array[a*4 + vert];							\
+		GLubyte col[4];															\
+		col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a;				\
+		glVertexAttrib4ubvARB(attribs.mcol[b].glIndex, col);					\
+	}																			\
+	if(attribs.tottang) {														\
+		float *tang = attribs.tang.array[a*4 + vert];							\
+		glVertexAttrib4fvARB(attribs.tang.glIndex, tang);						\
+	}																			\
+}
+
+	totface = ccgSubSurf_getNumFaces(ss);
+	for(a = 0, i = 0; i < totface; i++) {
+		CCGFace *f = ccgdm->faceMap[i].face;
+		int S, x, y, drawSmooth;
+		int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(ss, f));
+		int origIndex = ccgDM_getFaceMapIndex(ss, f);
+		
+		numVerts = ccgSubSurf_getFaceNumVerts(f);
+
+		/* get flags */
+		if(faceFlags) {
+			drawSmooth = (faceFlags[index*2] & ME_SMOOTH);
+			new_matnr= faceFlags[index*2 + 1] + 1;
+		}
+		else {
+			drawSmooth = 1;
+			new_matnr= 1;
+		}
+
+		/* material */
+		if(new_matnr != matnr) {
+			setMaterial(userData, matnr = new_matnr, &gattribs);
+			DM_vertex_attributes_from_gpu(dm, &gattribs, &attribs);
+		}
+
+		/* face hiding */
+		if((setFace && (origIndex != ORIGINDEX_NONE) && !setFace(userData, origIndex))) {
+			a += gridFaces*gridFaces*numVerts;
+			continue;
+		}
+
+		/* draw face*/
+		glShadeModel(drawSmooth? GL_SMOOTH: GL_FLAT);
+		for (S=0; S<numVerts; S++) {
+			DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
+			DMGridData *vda, *vdb;
+
+			if (drawSmooth) {
+				for (y=0; y<gridFaces; y++) {
+					glBegin(GL_QUAD_STRIP);
+					for (x=0; x<gridFaces; x++) {
+						vda = &faceGridData[(y+0)*gridSize + x];
+						vdb = &faceGridData[(y+1)*gridSize + x];
+						
+						PASSATTRIB(0, 0, 0);
+						glNormal3fv(vda->no);
+						glVertex3fv(vda->co);
+
+						PASSATTRIB(0, 1, 1);
+						glNormal3fv(vdb->no);
+						glVertex3fv(vdb->co);
+
+						if(x != gridFaces-1)
+							a++;
+					}
+
+					vda = &faceGridData[(y+0)*gridSize + x];
+					vdb = &faceGridData[(y+1)*gridSize + x];
+
+					PASSATTRIB(0, 0, 3);
+					glNormal3fv(vda->no);
+					glVertex3fv(vda->co);
+
+					PASSATTRIB(0, 1, 2);
+					glNormal3fv(vdb->no);
+					glVertex3fv(vdb->co);
+
+					glEnd();
+
+					a++;
+				}
+			} else {
+				glBegin(GL_QUADS);
+				for (y=0; y<gridFaces; y++) {
+					for (x=0; x<gridFaces; x++) {
+						float *aco = faceGridData[(y+0)*gridSize + x].co;
+						float *bco = faceGridData[(y+0)*gridSize + x + 1].co;
+						float *cco = faceGridData[(y+1)*gridSize + x + 1].co;
+						float *dco = faceGridData[(y+1)*gridSize + x].co;
+
+						ccgDM_glNormalFast(aco, bco, cco, dco);
+
+						PASSATTRIB(0, 1, 1);
+						glVertex3fv(dco);
+						PASSATTRIB(1, 1, 2);
+						glVertex3fv(cco);
+						PASSATTRIB(1, 0, 3);
+						glVertex3fv(bco);
+						PASSATTRIB(0, 0, 0);
+						glVertex3fv(aco);
+						
+						a++;
+					}
+				}
+				glEnd();
+			}
+		}
+	}
+
+#undef PASSATTRIB
+
+	ccgFaceIterator_free(fi);
+}
+
+
 static void ccgDM_drawFacesColored(DerivedMesh *dm, int UNUSED(useTwoSided), unsigned char *col1, unsigned char *col2) {
 	CCGDerivedMesh *ccgdm = (CCGDerivedMesh*) dm;
 	CCGSubSurf *ss = ccgdm->ss;
@@ -2382,6 +2531,7 @@ static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
 	ccgdm->dm.drawMappedFaces = ccgDM_drawMappedFaces;
 	ccgdm->dm.drawMappedFacesTex = ccgDM_drawMappedFacesTex;
 	ccgdm->dm.drawMappedFacesGLSL = ccgDM_drawMappedFacesGLSL;
+	ccgdm->dm.drawMappedFacesMat = ccgDM_drawMappedFacesMat;
 	ccgdm->dm.drawUVEdges = ccgDM_drawUVEdges;
 
 	ccgdm->dm.drawMappedEdgesInterp = ccgDM_drawMappedEdgesInterp;