def initData(filepath=None, texpath=None):
global objs
if not filepath:
filepath=Path("files/sphere.obj")
if not texpath:
texpath=Path("texture/earth")
obj_data = io.read_obj(filepath)
sphere = io.read_obj("files/sphere.obj")
# cube_data = io.read_obj("files/cube.obj")
obj = Object(obj_data, [1.0, 1.0, 1.0])
light = Object(sphere, [1.0, 1.0, 1.0])
sky = Object(sphere, [0.8, 0.8, 0.8])
if Path(texpath).is_dir():
obj_tex = Cubemap()
else:
obj_tex = Texture()
obj_tex.load(Path(texpath))
stars = Texture()
stars.load("texture/milky_way.jpg")
moon = Texture()
moon.load("texture/moon.jpg")
# for key in earth.faces:
# print(f'{key}: {earth.faces[key].filename}')
sky.create(stars)
obj.create(obj_tex)
# obj.create()
light.create(moon)
objs = [obj, light, sky]
# objs = [obj, light]
# Place objects in center
light.translate(-light.x, -light.y, -light.z)
obj.translate(-obj.x, -obj.y, -obj.z)
sky.translate(-sky.x, -sky.y, -sky.z-1)
light.scale(0.1, 0.1, 0.1)
sky.scale(10,10,10)
sky.rotate('y', 145)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LESS)
# Unbind Vertex Array Object.
gl.glBindVertexArray(0)
def __init__(self, main, ScreenManager, tileSizeX, tileSizeY, map="base"):
self.main = main
self.screenManager = ScreenManager
self.display_surf = ScreenManager.display_surf
self.middle = ScreenManager.size[0]/2
self.tileSizeX = tileSizeX # H
self.tileSizeY = tileSizeY # W
self.IsoMathHelper = None
self._IsoMathHelperInit()
self.MapPos = self.MapPosX, self.MapPosY = 0, 0
self.MapMovConst = 10
self.RegisterMapMovement()
self.RecalculateDisplayTiles = True
self.RDT_X_S = None
self.RDT_X_E = None
self.RDT_Y_S = None
self.RDT_Y_E = None
self.Map = Map(map)
self.Map.loadMap()
print(self.Map.sizeX)
self.MapJSON = MapJSON(map)
self.MapJSON.loadMap()
print(self.MapJSON.sizeX)
self.tiles = []
self.loadTextures()
self.screenManager.setBackgrounColor(self.screenManager.colors["Black"], 1.0)
self.MouseSelectedTexture = Texture("resources/graphics/map/select_tile.png")
self.test = Texture("resources/graphics/map/holzblock.png")
self.MouseActive = True
self.InGameMenuActive = False
self.button = Button(self.main,
self.display_surf,
self.screenManager.colors["Gray"],
self.screenManager.colors["Blue"],
self.screenManager.colors["Yellow"],
self.screenManager.colors["White"],
self.middle-200,
(self.screenManager.size[1]/10)*2+140,
400, 80,
"Create Level", 60,
self.place)
self.main.EventHandler.registerKEYDOWNevent(K_ESCAPE, self.KEYDOWNesc)
self.main.EventHandler.registerMOUSEBUTTONDOWNevent(1, self.place)
self.button.draw()
def __init__(self, texture_filename, position_x, position_y, width,
height):
self.texture = Texture(texture_filename)
self.x = position_x
self.y = position_y
self.size['width'] = width
self.size['height'] = height
def _genTextures(self):
self.BordSurf = pygame.Surface(self.size)
self.HoverSurf = pygame.Surface(self.size)
pygame.draw.rect(self.BordSurf, self.bord_color, self.Rect,
self.border)
pygame.draw.rect(self.BordSurf, self.in_color, self.InRect, 0)
self.BordSurf.blit(self.textSurf, self.textRect)
pygame.draw.rect(self.HoverSurf, self.hover_color, self.Rect,
self.border)
pygame.draw.rect(self.HoverSurf, self.in_color, self.InRect, 0)
self.HoverSurf.blit(self.textSurf, self.textRect)
self.HoverTexture = Texture(None, self.HoverSurf, self.Rect)
self.BoardTexture = Texture(None, self.BordSurf, self.Rect)
def generateTextureInfo(self):
# Figure out texture size
self.mTextureWidth, self.mTextureHeight = self.getTextureDimension(self.mTotalIndices)
# Initialize an array of target textures based upon the chosen settings
self.mTextures = [Texture(self.mTextureWidth, self.mTextureHeight, self.mView, view) for view in self.mView.getTextureViews()]
def __init__(self):
self.texture = Texture('resources/piste2.png')
self.tracklist = {}
self.trackelt = [{
'type': 'straight',
'L': 5.4
}, {
'type': 'turn',
'L': 0.7,
'sweep': math.radians(135)
}, {
'type': 'straight',
'L': 2
}, {
'type': 'turn',
'L': 0.5,
'sweep': math.radians(78.65)
}, {
'type': 'turn',
'L': 4.5,
'sweep': -math.radians(90)
}, {
'type': 'turn',
'L': 0.8,
'sweep': math.radians(146.35)
}, {
'type': 'straight',
'L': 1.7
}, {
'type': 'turn',
'L': 1.4,
'sweep': math.radians(90)
}]
def __init__(self, context, ImgData):
self.ImgData = None
self.texture = None
self.context = context
self.cache = None
self.transform = SvgTransform()
self.filename = ImgData
self.triangVtx = np.zeros((4,2), dtype=float32)
self.textriangVtx = np.zeros((4,2), dtype=float32)
# Detect the type of data passed in
if type(ImgData) == file:
self.ImgData = ImgData.read()
elif type(ImgData) == str:
self.texture = Texture(ImgData)
# bitmapFile = ImgData.replace(".svg", ".png")
# # Load PNG files directly
# if ImgData.endswith(".png"):
# self.texture = Texture(ImgData)
# elif ImgData.endswith(".jpg"):
# self.texture = Texture(ImgData)
# elif ImgData.endswith(".jpeg"):
# self.texture = Texture(ImgData)
# Check whether we have a prerendered bitmap version of the SVG file
# elif ImgData.endswith(".svg") and os.path.exists(bitmapFile):
# Log.debug("Loading cached bitmap '%s' instead of '%s'." % (bitmapFile, ImgData))
# self.texture = Texture(bitmapFile)
# else:
# if not haveAmanith:
# e = "PyAmanith support is deprecated and you are trying to load an SVG file."
# Log.error(e)
# raise RuntimeError(e)
# Log.debug("Loading SVG file '%s'." % (ImgData))
# self.ImgData = open(ImgData).read()
elif isinstance(ImgData, Image.Image): #stump: let a PIL image be passed in
self.texture = Texture()
self.texture.loadImage(ImgData)
# Make sure we have a valid texture
if not self.texture:
if type(ImgData) == str:
e = "Unable to load texture for %s." % ImgData
else:
e = "Unable to load texture for SVG file."
Log.error(e)
raise RuntimeError(e)
def __init__(self, texture_filename, position_x, position_y, width, height,
visible, speed):
self.texture = Texture(texture_filename)
self.x = position_x
self.y = position_y
self.size['width'] = width
self.size['height'] = height
self.visible = visible
self.speed = speed
def loadTextureFile(self):
if not self.textureFile: return
f = open(self.textureFile, 'r')
self.textures = []
for line in f:
l = line.strip()
if not l: continue
self.textures.append(Texture(l))
def AddTexture(self, Display, ID, Filename):
if ID == "":
return
NewTexture = Texture()
if not NewTexture.Load(Display, Filename):
Log("Unable to Load Texture:", ID)
return
self.TexList[ID] = NewTexture
def __init__(self, file_name):
global active_camera
self.models = None
self.cameras = None
self.lights = None
self.active_camera = active_camera
# shared resources
self.textures = {} # name -> tex lookup
self.shaders = {} # name -> tex lookup
self.meshes = {} # name -> tex lookup
with open(file_name, "r") as fp:
data = json.load(fp)
# models
self.models = {name: Model(m) for (name, m) in data["models"].items()}
for model in self.models.values():
vert_file = model.io['shader']['vert']
frag_file = model.io['shader']['frag']
shader_name = vert_file.split('.')[0]
shader = ResourceManager.get_shader(shader_name)
if not shader:
shader = Shader(vert_file, frag_file)
ResourceManager.add_shader(shader_name, shader)
model.shader = shader
mesh_name = model.io['mesh'] # contains relative path string
mesh = ResourceManager.get_mesh(mesh_name)
if not mesh:
mesh = Mesh(mesh_name)
ResourceManager.add_mesh(mesh_name, mesh)
model.mesh = mesh
tex_files = model.io['textures']
for (layer, tex_file) in tex_files.items():
tex = ResourceManager.get_texture(tex_file)
if not tex:
tex = Texture(tex_file)
ResourceManager.add_texture(tex_file, tex)
model.textures[layer] = tex
# cameras, set first camera to active
self.cameras = {
name: Camera(c)
for (name, c) in data["cameras"].items()
}
if len(self.cameras) > 0:
# get first items value
active_camera = next(iter(self.cameras.items()))[1]
logging.warn('camera needs to set shader uniforms')
# lights
self.lights = {name: Light(l) for (name, l) in data["lights"].items()}
logging.warn('light needs to set shader uniforms')
def loadItemLabel(self, i):
# Load the item label if it isn't yet loaded
item = self.items[i]
if self.itemLabels[i] is None:
if isinstance(item, Song.SongInfo):
label = self.engine.resource.fileName(self.library, item.songName, "label.png")
else:
assert isinstance(item, Song.LibraryInfo)
label = self.engine.resource.fileName(item.libraryName, "label.png")
if os.path.exists(label):
self.itemLabels[i] = Texture(label)
def __init__(self, context, ImgData):
self.ImgData = None
self.texture = None
self.context = context
self.cache = None
self.filename = ImgData
# Detect the type of data passed in
if isinstance(ImgData, file):
self.ImgData = ImgData.read()
elif isinstance(ImgData, basestring):
self.texture = Texture(ImgData)
elif isinstance(ImgData,
Image.Image): #stump: let a PIL image be passed in
self.texture = Texture()
self.texture.loadImage(ImgData)
# Make sure we have a valid texture
if not self.texture:
if isinstance(ImgData, basestring):
e = "Unable to load texture for %s." % ImgData
else:
e = "Unable to load texture for SVG file."
Log.error(e)
raise RuntimeError(e)
self.pixelSize = self.texture.pixelSize #the size of the image in pixels (from texture)
self.position = [0.0, 0.0] #position of the image in the viewport
self.scale = [1.0, 1.0] #percentage scaling
self.angle = 0 #angle of rotation (degrees)
self.color = (1.0, 1.0, 1.0, 1.0) #glColor rgba
self.rect = (0, 1, 0, 1) #texture mapping coordinates
self.shift = -.5 #horizontal alignment
self.vshift = -.5 #vertical alignment
self.path = self.texture.name #path of the image file
self.texArray = np.zeros((4, 2), dtype=np.float32)
self.createTex()
def tracker(i):
boxes = Boxes(len(files))
tex = Texture()
ims = Slicer()
th = Threshold()
hog = Hog()
cells = Cells(sizeh, sizew)
names = list(listdir(path))
names = names[i:i + batch_size]
net = Network()
net.load('data/net/dataset_184_nets_ann/', 'compile_config.txt',
hog_block_size, hog_cell_size, hog_orientations)
index = 0
while (len(names) > 0):
index = len(names) - 1
name = names.pop()
img = cv2.imread(path + name)
img_grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
images, coords = ims.split(img_grey, sizeh, sizew, sizeh, sizew)
signal = tex.analize(images, haralick_feature)
indexes = th.threshold_mean(signal)
#coords_f = []
#for x in indexes:
# coords_f.append(coords[x])
coords = coords[indexes]
coords = cells.group(coords)
coords = cells.reorganize_coords(coords)
for c in coords:
part_img = img_grey[c[2]:c[3], c[0]:c[1]]
part_img = cv2.resize(part_img, resize_img)
part = hog.runOne(part_img,
orient=hog_orientations,
pixels=hog_cell_size,
cells=hog_block_size)
part = part.reshape((1, part.shape[0]))
Y = net.predict(part)[0, 0]
if (Y > thresh and c[0] != 0 and c[1] != 500
and abs(c[0] - c[1]) * abs(c[2] - c[3]) > 625):
cells.box2(img, c)
box = Box()
box.box = [c[0], c[2], c[1], c[3]]
boxes.add(index, box)
cv2.imwrite(path_out + name, img)
boxes.save('boxes_predicted_ann_25.b')
def __init__(self, context, svgData):
self.svgData = None
self.texture = None
self.context = context
self.cache = None
self.transform = SvgTransform()
# Detect the type of data passed in
if type(svgData) == file:
self.svgData = svgData.read()
elif type(svgData) == str:
bitmapFile = svgData.replace(".svg", ".png")
# Load PNG files directly
if svgData.endswith(".png"):
self.texture = Texture(svgData)
# Check whether we have a prerendered bitmap version of the SVG file
elif svgData.endswith(".svg") and os.path.exists(bitmapFile):
Log.debug("Loading cached bitmap '%s' instead of '%s'." %
(bitmapFile, svgData))
self.texture = Texture(bitmapFile)
else:
if not haveAmanith:
e = "PyAmanith support is deprecated and you are trying to load an SVG file."
Log.error(e)
raise RuntimeError(e)
Log.debug("Loading SVG file '%s'." % (svgData))
self.svgData = open(svgData).read()
# Make sure we have a valid texture
if not self.texture:
if type(svgData) == str:
e = "Unable to load texture for %s." % svgData
else:
e = "Unable to load texture for SVG file."
Log.error(e)
raise RuntimeError(e)
def testRenderToTexture(self):
scale = 4
fullwidth, fullheight = 512, 512
width, height = int(fullwidth / scale), int(fullheight / scale)
t = Texture()
self.e.svg.setProjection((0, 0, fullwidth, fullheight))
t.prepareRenderTarget(width, height)
t.setAsRenderTarget()
glViewport(0, 0, width, height)
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT)
self.svg.transform.translate(width * scale / 2, height * scale / 2)
self.svg.transform.rotate(3.141592)
self.svg.draw()
t.resetDefaultRenderTarget()
glViewport(0, 0, fullwidth, fullheight)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluOrtho2D(0.0, 1.0, 0.0, 1.0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
t.bind()
glEnable(GL_TEXTURE_2D)
if not t.framebuffer.emulated:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glClear(GL_COLOR_BUFFER_BIT)
glColor3f(1.0, 1.0, 1.0)
glBegin(GL_TRIANGLE_STRIP)
glTexCoord2f(0.0, 0.0)
glVertex2f(0.0, 0.0)
glTexCoord2f(1.0, 0.0)
glVertex2f(1.0, 0.0)
glTexCoord2f(0.0, 1.0)
glVertex2f(0.0, 1.0)
glTexCoord2f(1.0, 1.0)
glVertex2f(1.0, 1.0)
glEnd()
self.e.video.flip()
import time
time.sleep(2)
def tracker(i):
boxes = Boxes(len(files))
tex = Texture()
ims = Slicer()
th = Threshold()
hog = Hog()
cells = Cells(sizeh,sizew)
names = list(listdir(path))
names = names[i:i+batch_size]
f = open('data/net/dataset_184_nets_svm/svm_c_2_p_8_o_2.svm','rb')
clf = pickle.load(f)
f.close()
while(len(names)>0):
index = len(names)-1
name = names.pop()
img = cv2.imread(path+name)
img_grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
images,coords = ims.split(img_grey,sizeh,sizew,sizeh,sizew)
signal_p = tex.analize(images,haralick_feature)
indexes = th.threshold_mean(signal_p)
coords_f = []
for x in indexes:
coords_f.append(coords[x])
coords = cells.group(coords_f)
coords = cells.reorganize_coords(coords)
for c in coords:
part_img = img_grey[c[2]:c[3],c[0]:c[1]]
part_img = cv2.resize(part_img,resize_img)
part = hog.runOne(part_img,orient=hog_orientations,pixels=hog_cell_size,cells=hog_block_size)
part = part.reshape((1,part.shape[0]))
Y = clf.predict(part)
if(Y>thresh and c[0]!=0 and c[1]!=500 and abs(c[0]-c[1])*abs(c[2]-c[3])>625 ):
cells.box2(img,c)
box = Box()
box.box = [c[0],c[2],c[1],c[3]]
boxes.add(index,box)
cv2.imwrite(path_out+name,img)
boxes.save('boxes_predicted_svm_25.b')
def cacheGlyph(self, ch):
"""
Add character and size to glyph caches
@param ch: Character
@return: Glyph instance
"""
# Font size
self.glyphSizeCache[ch] = self.font.size(ch)
# Font texture
s = self.font.render(ch, True, (255, 255, 255))
t = Texture()
t.setFilter(GL_LINEAR, GL_LINEAR)
t.setRepeat(GL_CLAMP, GL_CLAMP)
t.loadSurface(s, alphaChannel=True)
del s
self.glyphCache[ch] = t
return t
def tracker(i):
boxes = Boxes(len(files))
tex = Texture()
ims = Slicer()
th = Threshold()
cells = Cells(sizeh,sizew)
names = list(listdir(path))
names = names[i:i+batch_size]
f = open('svmsemhog.svm','rb')
clf = pickle.load(f)
f.close()
while(len(names)>0):
index = len(names)-1
name = names.pop()
img = cv2.imread(path+name)
img_grey = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
images,coords = ims.split(img_grey,sizeh,sizew,sizeh,sizew)
signal_p = tex.analize(images,haralick_feature)
indexes = th.threshold_mean(signal_p)
coords_f = []
for x in indexes:
coords_f.append(coords[x])
coords = cells.group(coords_f)
coords = cells.reorganize_coords(coords)
for c in coords:
part_img = img_grey[c[2]:c[3],c[0]:c[1]]
part_img = cv2.resize(part_img,resize_img).flatten()
print(part_img)
input()
Y = clf.predict(part_img)
if(Y>thresh and c[0]!=0 and c[1]!=500 and abs(c[0]-c[1])*abs(c[2]-c[3])>625 ):
cells.box2(img,c)
box = Box()
box.box = [c[0],c[2],c[1],c[3]]
boxes.add(index,box)
cv2.imwrite(path_out+name,img)
boxes.save('boxes_predicted_svm.b')
def __init__(self, texture_path):
self.texture_path = texture_path
self.texture_size = 16 # 16*16 texture size
self.textures = {}
for texture in json.load(open(TEXTURE_CONFIG_FILE)).items():
name = texture[0]
settings = texture[1]
texture_coords = settings["texture_coords"]
mining_level = settings["mining_level"]
damage = settings["damage"]
top, bottom, side = texture_coords
self.textures[name] = Texture(
name, self.get_texture_coordinates(top, bottom, side),
mining_level, damage)
self.indestructible_resources = [
resource for resource in self.textures.values()
if resource.indestructible
]
self.world_resources = [
texture for texture in list(self.textures.values())
if texture not in self.indestructible_resources
]
self.resource_levels = [
self.textures["dirt"], self.textures["stone"],
self.textures["bedrock"]
]
self.wall_resource = self.textures["bedrock"]
self.faces = [
(0, 1, 0),
(0, -1, 0),
(-1, 0, 0),
(1, 0, 0),
(0, 0, 1),
(0, 0, -1),
]
def initializeGL(self):
glClearColor(0.0, 0.0, 0.0, 1.0)
glClearDepth(1.0)
domeStr = "CanvasModel.Dome"
self.shaders[domeStr + "_proj"] = Shader("shaders/dome_proj.vert",
"shaders/dome_4proj.frag")
self.shaders[domeStr + "_edgeblend"] = Shader(
"shaders/dome_edgeblend.vert", "shaders/dome_edgeblend_4proj.frag")
self.shaders[domeStr + "_inv_proj"] = Shader(
"shaders/dome_inv_proj.vert", "shaders/dome_inv_proj.frag")
# cycloramaStr = "CanvasModel.Cyclorama"
# self.shaders[cycloramaStr+"_proj"] = Shader("shaders/cyclorama_proj.vert","shaders/dome_proj.frag")
# self.shaders[cycloramaStr+"_edgeblend"] = Shader("shaders/cyclorama_edgeblend.vert","shaders/cyclorama_edgeblend.frag")
# self.shaders[cycloramaStr+"_inv_proj"] = Shader("shaders/dome_inv_proj.vert","shaders/dome_inv_proj.frag")
for textureFile in self.textureFiles:
texFile = os.path.join(TEXTURE_PATH, textureFile)
self.textures[textureFile[:-4]] = Texture(texFile)
print aruco.drawDetectedMarkers
#cv2.aruco.drawMarker()
#dic = cv2.aruco.getPredefinedDictionary(cv2.acuro.DICT_6X6_250)
#print cv2.aruco
print help(cv2)
bridge = CvBridge()
with open('camera_calib.pickle', 'r') as f:
ret, mtx, dist, rvecs, tvecs, objpoints, imgpoints = pickle.load(f)
window = Window(640, 480, 16, 'OpenCV+OpenGL')
webcam_image = np.zeros((480, 640, 3), dtype=np.uint8)
tex = Texture(webcam_image.shape[:2])
fbo = Framebuffer(*webcam_image.shape[:2])
Texture.handlesToUBO([tex.handle, fbo.color_handle])
def callback(data):
webcam_image[:] = bridge.imgmsg_to_cv2(data, "passthrough")
rospy.init_node('listener', anonymous=True, disable_signals=True)
rospy.Subscriber("/rgb/image", Image, callback, queue_size=1)
thread.start_new_thread(rospy.spin, ())
screen_shader = Shader('shader/screen_shader.vs', 'shader/screen_shader.frag')
color_shader = Shader('shader/color_shader.vs', 'shader/color_shader.frag')
quad_shader = Shader('shader/quad_shader.vs', 'shader/quad_shader.frag')
glNamedFramebufferTexture(fbo, GL_COLOR_ATTACHMENT0, tex[0], 0)
glNamedFramebufferTexture(fbo, GL_DEPTH_ATTACHMENT, tex[1], 0)
color_handle = glGetTextureHandleNV(tex[0])
glMakeTextureHandleResidentNV(color_handle)
depth_handle = glGetTextureHandleNV(tex[1])
glMakeTextureHandleResidentNV(depth_handle)
assert glCheckNamedFramebufferStatus(fbo, GL_FRAMEBUFFER)\
== GL_FRAMEBUFFER_COMPLETE, 'Framebuffer not complete'
return fbo, color_handle
fbo, color_handle = createFramebuffer(640, 480, 1)
tex = Texture(raw_im.shape[:2])
handles = np.empty(2, dtype=np.uint64)
handles[0] = tex.getHandle()
handles[1] = color_handle
ubo = np.empty(1, dtype=np.uint32)
glCreateBuffers(len(ubo), ubo)
glNamedBufferStorage( ubo[0], handles.nbytes, handles, 0)
glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 2, ubo[0], 0, handles.nbytes)
def callback(data):
try:
#lock.acquire()
dat = bridge.imgmsg_to_cv2(data, "passthrough")
raw_im[:] = dat
iA, iB, iC = [dot(n, render.light) for n in (nA, nB, nC)]
intensity = w * iA + v * iB + u * iC
intensity = intensity / 4
if (tcolor):
return color(
int(tcolor[2] * intensity) if tcolor[0] * intensity > 0 else 0,
int(tcolor[1] * intensity) if tcolor[1] * intensity > 0 else 0,
int(tcolor[0] * intensity) if tcolor[2] * intensity > 0 else 0)
else:
return color(0, 0, 0)
def table(render, **kwargs):
tx, ty = kwargs['texture_coords']
return color(255, 255, 255)
r = Render(800, 800)
t = Texture('./models/model.bmp')
r.light = V3(0, 1, 1)
r.active_texture = t
r.active_shader = fragment
r.lookAt(V3(1, 0, 5), V3(0, 0, 0), V3(0, 1, 0))
r.load('./models/model.obj',
translate=(0, 0, 0),
scale=(1, 1, 1),
rotate=(0, 0, 0))
r.draw_arrays('TRIANGLES')
r.display('out.bmp')
def loadTexture(self, filename):
self.texture = Texture(self.renderer, filename).filename
def render(self, text, pos = (0, 0), direction = (1, 0), scale = DEFAULT_SCALE, shadowoffset = (.0022, .0005)):
"""
Draw some text.
@param text: Text to draw
@param pos: Text coordinate tuple (x, y)
@param direction: Text direction vector (x, y, z)
@param scale: Scale factor
"""
# deufeufeu : new drawing relaying only on pygame.font.render
# : I know me miss special unicodes characters, but the gain
# : is really important.
# evilynux : Use arrays to increase performance
def drawSquare(w,h,tw,th):
self.square_prim[1,0] = self.square_prim[3,0] = w
self.square_prim[2,1] = self.square_prim[3,1] = h
self.square_tex[0,1] = self.square_tex[1,1] = th
self.square_tex[1,0] = self.square_tex[3,0] = tw
glEnableClientState(GL_VERTEX_ARRAY)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointerf(self.square_prim)
glTexCoordPointerf(self.square_tex)
glDrawArrays(GL_TRIANGLE_STRIP, 0, self.square_prim.shape[0])
glDisableClientState(GL_VERTEX_ARRAY)
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if not text:
return
try:
t,w,h = self.stringsCache.get(text)
except KeyError:
s = self.font.render(text, True, (255,255,255))
t = Texture()
t.setFilter(GL_LINEAR, GL_LINEAR)
t.setRepeat(GL_CLAMP, GL_CLAMP)
t.loadSurface(s, alphaChannel = True)
del s
w, h = self.font.size(text)
self.stringsCache.add(text,(t,w,h))
x, y = pos
scale *= self.scale
w, h = w*scale, h*scale
tw,th = t.size
glEnable(GL_TEXTURE_2D)
glPushMatrix()
glTranslatef(x,y,0)
t.bind()
if self.outline:
glPushAttrib(GL_CURRENT_BIT)
glColor4f(0, 0, 0, .25 * glGetDoublev(GL_CURRENT_COLOR)[3])
blur = 2 * DEFAULT_SCALE
for offset in [(-.7, -.7), (0, -1), (.7, -.7), (-1, 0),
(1, 0), (-.7, .7), (0, 1), (.7, .7)]:
glTranslatef(blur * offset[0], blur * offset[1], 0)
drawSquare(w,h,tw,th)
glTranslatef(-blur * offset[0], -blur * offset[1], 0)
glPopAttrib()
if self.shadow:
glPushAttrib(GL_CURRENT_BIT)
glColor4f(0, 0, 0, 1)
glTranslatef(shadowoffset[0], shadowoffset[1], 0)
drawSquare(w,h,tw,th)
glTranslatef(-shadowoffset[0], -shadowoffset[1], 0)
glPopAttrib()
drawSquare(w,h,tw,th)
glPopMatrix()
glDisable(GL_TEXTURE_2D)
return
def render(self,
text,
pos=(0, 0),
rotate=0,
scale=DEFAULT_SCALE,
shadowoffset=(.0022, .0005),
align=LEFT,
new=False,
shadow=False,
outline=False,
shadowOpacity=1.0):
"""
Draw some text.
@param text: Text to draw
@param pos: Text coordinate tuple (x, y)
@param rotate: Angle to rotate text, in degrees
@param scale: Scale factor
"""
# deufeufeu : new drawing relaying only on pygame.font.render
# : I know me miss special unicodes characters, but the gain
# : is really important.
# evilynux : Use arrays to increase performance
def drawSquare(w, h, tw, th):
self.square_prim[1, 0] = self.square_prim[3, 0] = w
self.square_prim[2, 1] = self.square_prim[3, 1] = h
self.square_tex[0, 1] = self.square_tex[1, 1] = th
self.square_tex[1, 0] = self.square_tex[3, 0] = tw
cmgl.drawArrays(GL_TRIANGLE_STRIP,
vertices=self.square_prim,
texcoords=self.square_tex)
if not text:
return
try:
t, w, h = self.stringsCache.get(text)
except KeyError:
s = self.font.render(text, True, (255, 255, 255))
t = Texture()
t.setFilter(GL_LINEAR, GL_LINEAR)
t.setRepeat(GL_CLAMP, GL_CLAMP)
t.loadSurface(s, alphaChannel=True)
del s
w, h = self.font.size(text)
self.stringsCache.add(text, (t, w, h))
x, y = pos
scale *= self.scale
w, h = w * scale * self.aspectRatioFactor, h * scale
if align == CENTER: #we have already done all the calculating. Why not add this? - akedrou
x -= (w / 2)
elif align == RIGHT:
x -= w
y -= (h / 2)
tw, th = t.size
glEnable(GL_TEXTURE_2D)
with cmgl.PushedMatrix():
if rotate:
if not isinstance(rotate, tuple):
glRotatef(rotate, 0, 0, 1.0)
else:
glRotatef(0, *rotate)
glTranslatef(x, y, 0)
t.bind()
if self.outline or outline:
with cmgl.PushedAttrib(GL_CURRENT_BIT):
glColor4f(0, 0, 0, .25 * glGetDoublev(GL_CURRENT_COLOR)[3])
blur = 2 * DEFAULT_SCALE
for offset in [(-.7, -.7), (0, -1), (.7, -.7), (-1, 0),
(1, 0), (-.7, .7), (0, 1), (.7, .7)]:
with cmgl.PushedMatrix():
glTranslatef(blur * offset[0], blur * offset[1], 0)
drawSquare(w, h, tw, th)
if self.shadow or shadow:
with cmgl.PushedAttrib(GL_CURRENT_BIT):
glColor4f(
0, 0, 0,
glGetDoublev(GL_CURRENT_COLOR)[3] * shadowOpacity)
with cmgl.PushedMatrix():
glTranslatef(shadowoffset[0], shadowoffset[1], 0)
drawSquare(w, h, tw, th)
drawSquare(w, h, tw, th)
glDisable(GL_TEXTURE_2D)
mesh2 = Mesh("resources/meshes/plane2_p_n_uv1.ply")
mesh2.load()
mesh2.create()
mesh2_mat = pyrr.matrix44.create_from_translation(pyrr.Vector3([0, 0, 0]))
# mesh3 = Mesh("resources/meshes/Dragon.ply")
# mesh3.load()
# mesh3.create()
# mesh3_mat = pyrr.matrix44.create_from_translation(pyrr.Vector3([2, 1, .5]))
shader1 = Shader("resources/shaders/shader1.vs", "resources/shaders/shader1.fs")
shader1.load()
shader1.create()
# shader1.use() # needed
tex1 = Texture("resources/images/marble.jpg")
tex1.load()
tex1.create()
tex2 = Texture("resources/images/brickwall.jpg")
tex2.load()
tex2.create()
tex3 = Texture("resources/images/StoneMarbleCalacatta004_COL_2K.jpg")
tex3.load()
tex3.create()
light_pos = [0.0, 1.0, 3.0]
# set global render states
glClearColor(0, 0.1, 0.1, 1)
Then we Draw the stars in the sky, using a shader that use a random generator of
white points, and that random has lower probability when y is greater.
"""
stars(r)
"""
We draw to moons, using an sphere model, each one has different texture
and differnt shader to produce the effect of an celestial body. This models
were made using bump mapping.
"""
#Draw the moon Iscaco
t = Texture('./models/iscalo.bmp')
r.active_texture = t
r.active_light = norm(V3(0, 20, 0))
r.load('./models/sphere.obj', [-0.55, 0.70, 0], [0.22, 0.22, 0.22],
[0, 0.2, 0])
r.active_shader = moon
r.draw_arrays('TRIANGLES')
#Draw the moon Urica
t = Texture('./models/urica.bmp')
r.active_texture = t
r.load('./models/sphere.obj', [0.57, 0.80, 0], [0.20, 0.20, 0.20], [0, 0.2, 0])
r.active_shader = planet
r.draw_arrays('TRIANGLES')
"""
def __init__(self,half_width,half_height,filename): self.compiler=Compiler() self.background_t = Texture(TEXDIR+filename) self.background_geom=self.compiler.quad(half_width,half_height)
