~diresu/blender/blender-command-port

for win3d in Window.GetScreenInfo(Window.Types.VIEW3D): # we search all 3dwins for the one containing the point (screen_x, screen_y) (could be the mousecoords for example)

win_min_x, win_min_y, win_max_x, win_max_y = win3d['vertices']

# calculate a few geometric extents for this window

win_mid_x = (win_max_x + win_min_x + 1.0) * 0.5

win_mid_y = (win_max_y + win_min_y + 1.0) * 0.5

win_size_x = (win_max_x - win_min_x + 1.0) * 0.5

win_size_y = (win_max_y - win_min_y + 1.0) * 0.5

#useMid is for projecting the coordinates when we subdivide the screen into bins

if useMid: # == True

screen_x = win_mid_x

screen_y = win_mid_y

# if the given screencoords (screen_x, screen_y) are within the 3dwin we fount the right one...

if (win_max_x > screen_x > win_min_x) and ( win_max_y > screen_y > win_min_y):

# first we handle all pending events for this window (otherwise the matrices might come out wrong)

Window.QHandle(win3d['id'])

# now we get a few matrices for our window...

# sorry - i cannot explain here what they all do

# - if you're not familiar with all those matrices take a look at an introduction to OpenGL...

pm = Window.GetPerspMatrix() # the prespective matrix

pmi = Matrix(pm); pmi.invert() # the inverted perspective matrix

if (1.0 - epsilon < pmi[3][3] < 1.0 + epsilon):

# pmi[3][3] is 1.0 if the 3dwin is in ortho-projection mode (toggled with numpad 5)

hms = mouseViewRay.hms

ortho_d = mouseViewRay.ortho_d

# ortho mode: is a bit strange - actually there's no definite location of the camera ...

# but the camera could be displaced anywhere along the viewing direction.

ortho_d.x, ortho_d.y, ortho_d.z = Window.GetViewVector()

ortho_d.w = 0

# all rays are parallel in ortho mode - so the direction vector is simply the viewing direction

#hms.x, hms.y, hms.z, hms.w = (screen_x-win_mid_x) /win_size_x, (screen_y-win_mid_y) / win_size_y, 0.0, 1.0

hms[:] = (screen_x-win_mid_x) /win_size_x, (screen_y-win_mid_y) / win_size_y, 0.0, 1.0

# these are the homogenious screencoords of the point (screen_x, screen_y) ranging from -1 to +1

p=(hms*pmi) + (1000*ortho_d)

p.resize3D()

d[:] = ortho_d[:3]

# Finally we shift the position infinitely far away in

# the viewing direction to make sure the camera if outside the scene

# (this is actually a hack because this function

# is used in sculpt_mesh to initialize backface culling...)

else:

# PERSPECTIVE MODE: here everything is well defined - all rays converge at the camera's location

vmi = Matrix(Window.GetViewMatrix()); vmi.invert() # the inverse viewing matrix

fp = mouseViewRay.fp

dx = pm[3][3] * (((screen_x-win_min_x)/win_size_x)-1.0) - pm[3][0]

dy = pm[3][3] * (((screen_y-win_min_y)/win_size_y)-1.0) - pm[3][1]

fp[:] = \

pmi[0][0]*dx+pmi[1][0]*dy,\

pmi[0][1]*dx+pmi[1][1]*dy,\

pmi[0][2]*dx+pmi[1][2]*dy

# fp is a global 3dpoint obtained from "unprojecting" the screenspace-point (screen_x, screen_y)

#- figuring out how to calculate this took me quite some time.

# The calculation of dxy and fp are simplified versions of my original code

#- so it's almost impossible to explain what's going on geometrically... sorry

p[:] = vmi[3][:3]

# the camera's location in global 3dcoords can be read directly from the inverted viewmatrix

#d.x, d.y, d.z =normalize_v3(sub_v3v3(p, fp))

d[:] = p.x-fp.x, p.y-fp.y, p.z-fp.z

#print 'd', d, 'p', p, 'fp', fp

100

# the direction vector is simply the difference vector from the virtual camera's position

101

#to the unprojected (screenspace) point fp

102

103

# Do we want to return a direction in object's localspace?

104

105

if localMatrix:

106

localInvMatrix = Matrix(localMatrix)

107

localInvMatrix.invert()

108

localInvMatrix_notrans = localInvMatrix.rotationPart()

109

p = p * localInvMatrix

110

d = d * localInvMatrix # normalize_v3

111

112

# remove the translation from d

113

d.x -= localInvMatrix[3][0]

114

d.y -= localInvMatrix[3][1]

115

d.z -= localInvMatrix[3][2]

116

117

118

d.normalize()

119

'''

120

# Debugging

121

me = Blender.Mesh.New()

122

me.verts.extend([p[0:3]])

123

me.verts.extend([(p-d)[0:3]])

124

me.edges.extend([0,1])

125

ob = Blender.Scene.GetCurrent().objects.new(me)

126

'''

127

return True, p, d # Origin, Direction

128

129

# Mouse is not in any view, return None.

130

return False, None, None

131

132

# Constant function variables

133

mouseViewRay.d = Vector(0,0,0) # Perspective, 3d

134

mouseViewRay.p = Vector(0,0,0)

135

mouseViewRay.fp = Vector(0,0,0)

136

137

mouseViewRay.hms = Vector(0,0,0,0) # ortho only 4d

138

mouseViewRay.ortho_d = Vector(0,0,0,0) # ortho only 4d

139

140

141

LMB= Window.MButs['L']

142

def mouseup():

143

# Loop until click

144

mouse_buttons = Window.GetMouseButtons()

145

while not mouse_buttons & LMB:

146

Blender.sys.sleep(10)

147

mouse_buttons = Window.GetMouseButtons()

148

while mouse_buttons & LMB:

149

Blender.sys.sleep(10)

150

mouse_buttons = Window.GetMouseButtons()

151

152

153

if __name__=='__main__':

154

mouseup()

155

x,y= Window.GetMouseCoords()

156

isect, point, dir= mouseViewRay(x,y)

157

if isect:

158

scn= Blender.Scene.GetCurrent()

159

me = Blender.Mesh.New()

160

ob= Blender.Object.New('Mesh')

161

ob.link(me)

162

scn.link(ob)

163

ob.sel= 1

164

me.verts.extend([point, dir])

165

me.verts[0].sel= 1

166

167

print isect, point, dir

168

169

170

171

def spaceRect():

172

'''

173

Returns the space rect

174

xmin,ymin,width,height

175

'''

176

177

__UI_RECT__ = Blender.BGL.Buffer(Blender.BGL.GL_FLOAT, 4)

178

Blender.BGL.glGetFloatv(Blender.BGL.GL_SCISSOR_BOX, __UI_RECT__)

179

__UI_RECT__ = __UI_RECT__.list

180

__UI_RECT__ = int(__UI_RECT__[0]), int(__UI_RECT__[1]), int(__UI_RECT__[2])-1, int(__UI_RECT__[3])

181

182

return __UI_RECT__

183

184

def mouseRelativeLoc2d(__UI_RECT__= None):

185

if not __UI_RECT__:

186

__UI_RECT__ = spaceRect()

187

188

mco = Window.GetMouseCoords()

189

if mco[0] > __UI_RECT__[0] and\

190

mco[1] > __UI_RECT__[1] and\

191

mco[0] < __UI_RECT__[0] + __UI_RECT__[2] and\

192

mco[1] < __UI_RECT__[1] + __UI_RECT__[3]:

193

194

return (mco[0] - __UI_RECT__[0], mco[1] - __UI_RECT__[1])

195

196

else:

197

return None

198

199

200

201

202

203

204

205

206

b'\\ No newline at end of file'

Older »