Early bevel mapping test. But does not work like expected.
I have merged some parts from the “vertexpaint_selfshadow_ao.py” for the angle calculation and parts from the “uv_export.py” for drawing lines in a texture.
I’m sure there is a much smarter solution. 
The first Prepre-Alpha version of the bevel mapping script:
import Blender
import bpy
import BPyMesh
import BPyMessages
from math import *
def AddExtension(filename, object_name):
ext = ".tga"
hasExtension = (ext in filename or ext.upper() in filename)
if object_name and hasExtension:
filename = filename.replace(ext, "")
hasExtension = False
if object_name:
filename += "_" + object_name
if not hasExtension:
filename += ext
return filename
def GetDefaultFilename():
filename = Blender.Get("filename")
filename = filename.replace(".blend", "_bm")
filename += ".tga"
return filename
def ExtractUVFaces(mesh, allface):
if allface: return [f.uv for f in mesh.faces]
else: return [f.uv for f in mesh.faces if f.sel]
def Buffer(height=16, width=16, profondeur=1,rvb=127 ):
"""
reserve l'espace memoire necessaire
"""
p=[rvb]
myb=height*width*profondeur
print"Memory : %ikB" % (myb/1024)
b=p*myb
return b
def write_tgafile(loc2,bitmap,width,height,profondeur):
f=open(loc2,'wb')
Origine_en_haut_a_gauche=32
Origine_en_bas_a_gauche=0
Data_Type_2=2
RVB=profondeur*8
RVBA=32
entete0=[]
for t in range(18):
entete0.append(chr(0))
entete0[2]=chr(Data_Type_2)
entete0[13]=chr(width/256)
entete0[12]=chr(width % 256)
entete0[15]=chr(height/256)
entete0[14]=chr(height % 256)
entete0[16]=chr(RVB)
entete0[17]=chr(Origine_en_bas_a_gauche)
# Origine_en_haut_a_gauche
print" ...writing tga..."
for t in entete0:
f.write(t)
redpx=chr(0) + chr(0) + chr(255)
blackpx=chr(0) + chr(0) + chr(0)
whitepx=chr(255) + chr(255) + chr(255)
for t in bitmap:
if t==255:
f.write(whitepx)
elif t==127:
f.write(chr(127) + chr(127) + chr(127))
elif t==0:
f.write(blackpx)
else:
f.write(redpx)
f.close()
def BM_Export_TGA(mesh, size, wsize, file):
extreme_warning = False
DotVecs = Blender.Mathutils.DotVecs
Ang= Blender.Mathutils.AngleBetweenVecs
BPyMesh.meshCalcNormals(mesh)
UVFaces = ExtractUVFaces(mesh, True)
minx = 0
miny = 0
scale = 1.0
step = 0
img = Buffer(size,size)
max_index = size - 1 # max index of the buffer (height or width)
fnum = 0
fcnt = len (UVFaces)
for i, f in enumerate(mesh.faces):
fc= f.cent
# print "FaceCenter: %f %f %f" % (fc.x, fc.y, fc.z)
fno = f.no
# print "FaceNormal: %f %f %f" % (fno.x, fno.y, fno.z)
fuv = UVFaces[i]
vnum = 0
for v in f.v:
vno=v.no # get a scaled down normal.
# print dir(v)
# print "VertexNormal: %f %f %f" % (vno.x, vno.y, vno.z)
dot= DotVecs(vno, v.co) - DotVecs(vno, fc)
# vert_tone_count[v.index]+=1
try:
a= Ang(vno, fno)
except:
continue
if dot>0: # Convex
a= min(20, a)
color = 255
# print "Convex Angle: %f" %a
# if not PREF_SHADOW_ONLY:
# vert_tone[v.index] += a
elif dot == 0: # Planar
a=0
color = 1
else: # Concave
a= min(90, a)
color = 0
# print "Concave Angle: %f" %a
# vert_tone[v.index] -= a
co1=fuv[vnum]
if vnum < len(fuv) - 1:
co2 = fuv[vnum + 1]
else:
co2 = fuv[0]
print "co1: %f %f" % (co1.x, co1.y)
print "co2: %f %f" % (co2.x, co2.y)
step = int(ceil(size*sqrt((co1[0]-co2[0])**2+(co1[1]-co2[1])**2)))
if step:
try:
for t in xrange(step):
x = int(floor((co1[0] + t*(co2[0]-co1[0])/step) * max_index))
y = int(floor((co1[1] + t*(co2[1]-co1[1])/step) * max_index))
for dx in range(-1*wsize + 1, wsize):
wx = int ((x - minx + dx) * scale)
for dy in range(-1*wsize + 1, wsize):
wy = int ((y - miny + dy) * scale)
co = wx * 1 + wy * 1 * size
img[co] = color
except OverflowError:
if not extreme_warning:
print "Skipping extremely long UV edges, check your layout for excentric values"
extreme_warning = True
vnum=vnum+1
write_tgafile(file,img,size,size,3)
def ExportCallback(f):
obj = Blender.Scene.GetCurrent().objects.active
time1= Blender.sys.time()
if not obj or obj.type != "Mesh":
BPyMessages.Error_NoMeshActive()
return
is_editmode = Blender.Window.EditMode()
if is_editmode: Blender.Window.EditMode(0)
mesh = obj.getData(mesh=1)
if not mesh.faceUV:
if is_editmode: Blender.Window.EditMode(1)
BPyMessages.Error_NoMeshUvActive()
return
name = AddExtension(f, obj.name)
if is_editmode: Blender.Window.EditMode(1)
print
print "TGA export is running..."
BM_Export_TGA(mesh, bImageSize, bBevelSize, name)
print
print " ...finished exporting in %.4f sec." % (Blender.sys.time()-time1)
def Export():
Blender.Window.FileSelector(ExportCallback, "Save BevelMap (%s)" % "tga", GetDefaultFilename())
def main():
global bImageSize, bBevelSize, bObFile # , bWrap, bAllFaces
print
print "Bevel mapping"
bImageSize = 1024
bBevelSize = 3
print
print "Imagesize: %ipx" % bImageSize
print "Bevelsize : %ipx" % bBevelSize
Export()
Blender.Redraw()
if __name__=='__main__':
main()
- no Gui
- you have to select a mesh
- the mesh must have UV-coords. (Unwrap smart projection)
- The scene must be saved before running the script
- copy the script in a blender texteditor and press “Alt+P”
Than it works like the UV-export (only TGA).
Here a simple Mesh:
If I assign an “Edgesplit modifier”, I got this result:
The idea is to find convex und concave edges and paint a black or white line on the edge.
The red Lines are flat edges and will later get no bump.
Problems:
As you can see, there are a lot of Problems.
- With the logic from “vertexpaint self AO” I can detect flat faces only with an applied “edgesplit modifier”
- some edges are not correct detected.
- I need an other algorithm to detect the hard, converx/concave edges. I think I must compare faces.
- It’s really complicated to combine the UV Faces with the geometry edge detection in the mesh.
In some cases I get what I want, But I think it’s not the smartest way.
Do you have some suggestions?
I don’t really understand the logik with faces, vertices and UV Faces and UV Vertices.
I can iterate throught the UV faces (like in UV Export) or throught the geometry faces (like in the selfAO).
Currently I handle the Mesh coords with the same logik like the UV Coords. With the same face and vertex index. Is this always the same order?
