[91.5, 118.0], [90.4, 91.2], [89.3, 87.7], [86.9, 81.9], [84.5, 77.1],
[75.2, 66.0], [63.0, 55.6], [59.9, 54.4], [65.5, 49.4], [75.6, 36.8],
[80.3, 19.4], [82.3, 14.6], [87.3, 8.6], [95.8, -3.0], [99.8, -15.8],
[99.2, -28.8], [93.9, -41.3], [89.0, -51.8], [86.4, -64.7],
[83.7, -75.3], [78.4, -85.0], [71.0, -93.1], [61.8, -99.1],
[49.9, -105.8], [39.4, -111.7], [28.3, -119.0], [17.2, -126.2]]
edge_path = [[i[0], i[1], 1.0] for i in path] # make copy in 3D for edges
''' Polygon '''
poly = pi3d.Polygon(path=path, z=5)
poly.set_draw_details(shader, [tex], umult=5,
vmult=-5) # NB vmult -ve to flip texture
''' Lines for edges '''
edges = pi3d.PolygonLines(camera=camera,
vertices=edge_path,
closed=True,
line_width=5.0,
z=-1.0)
edges.set_material((0.0, 0.0, 0.0))
edges.set_shader(lineshader)
''' or try using texture and uv_flat shader '''
#tex2 = pi3d.Texture("textures/PATRN.PNG")
#edges.set_draw_details(shader, [tex2])
''' add edges as child of poly '''
poly.add_child(edges)
kb = pi3d.Keyboard()
sc = 1.0
while display.loop_running():
poly.draw() # only draw, rotate, scale parent Shape
poly.rotateIncZ(0.05)
seps.append((0, 240, 2.5))
seps.append((00, -240, 2.5))
seperator = pi3d.Lines(vertices=seps, line_width=10, strip=True)
seperator.set_shader(graphics.MATSH)
seperator.set_material((1, 1, 1))
seperator.set_alpha(0.1)
clock_sec = pi3d.Lines(vertices=[(0, 0, 1.2), (0, 140, 1.2)],
line_width=3,
strip=True)
clock_sec.set_shader(graphics.MATSH)
clock_sec.set_material((1, 0, 0))
clock_min = pi3d.PolygonLines(vertices=[(0, 0, 2), (0, 120, 2)],
line_width=7,
strip=True)
clock_min.set_shader(graphics.MATSH)
clock_min.set_material((0, 0, 0))
clock_hour = pi3d.PolygonLines(vertices=[(0, 0, 2), (0, 70, 2)],
line_width=15,
strip=True)
clock_hour.set_shader(graphics.MATSH)
clock_hour.set_material((0, 0, 0))
text = pi3d.PointText(graphics.pointFont,
graphics.CAMERA,
max_chars=80,
point_size=128)
storagearea.set_shader(graphics.MATSH)
storagearea.set_material((0.0, 0.0, 1.0))
floorplan = pi3d.ImageSprite(resource_filename("shpi",
"sprites/floorplan.png"),
shader=graphics.SHADER,
camera=graphics.CAMERA,
w=539,
h=450,
x=0,
y=0,
z=2.0)
doorneedle = pi3d.PolygonLines(camera=graphics.CAMERA,
vertices=((0, 0, 0), (60, 0, 0)),
material=(1.0, 0.3, 0.0),
line_width=20,
x=-13.0,
y=-220.0,
z=1.0)
doorneedle.set_shader(graphics.MATSH)
windowneedle = pi3d.PolygonLines(camera=graphics.CAMERA,
vertices=((0, 0, 0), (45, 0, 0)),
material=(0, 1, 0.0),
line_width=10,
x=-180.0,
y=217.0,
z=1.0)
windowneedle.set_shader(graphics.MATSH)
rotate = 0
def __init__(self,
width=600,
step=20,
x=-300,
y=0,
thickness=50,
min_t=1,
max_t=31):
self.width = width
self.step = step
self.thickness = thickness
self.min_t = min_t
self.max_t = max_t
self.x = x
self.y = y
self.value = max_t
tick_verts = []
dial_verts = []
bline_verts = []
# first make tick vertices
for x2 in range(0, self.width, self.step):
tick_verts.extend([(x2, -self.thickness / 2, 0.2),
(x2, self.thickness / 2, 0.2)])
bline_verts.append((x2, 0, 0.5))
for x2 in range(self.x - 9, self.x + self.width + 3, self.step):
dial_verts.append((x2, 0, 0.5))
tex = pi3d.Texture(
resource_filename("shpi", "sprites/color_gradient.jpg"))
self.ticks = pi3d.PolygonLines(camera=graphics.CAMERA,
x=self.x,
y=self.y,
vertices=tick_verts,
strip=False,
line_width=15)
self.ticks.set_shader(graphics.MATSH)
self.ticks.set_alpha(0.6)
self.bline = pi3d.PolygonLines(camera=graphics.CAMERA,
x=self.x,
y=self.y,
vertices=bline_verts,
line_width=self.thickness)
self.bline.set_textures([tex])
self.bline.set_alpha(0.5)
self.bline.set_shader(graphics.SHADER)
self.bline.set_material((0.5, 0.5, 0.5))
self.dial = pi3d.PolygonLines(camera=graphics.CAMERA,
x=0,
y=self.y,
vertices=dial_verts,
line_width=self.thickness + 6)
self.dial.set_alpha(0.4)
self.dial.set_shader(graphics.MATSH)
self.dial.set_material((0, 0, 0))
self.actval = pi3d.PointText(graphics.pointFont,
graphics.CAMERA,
max_chars=8,
point_size=100)
self.temp_set = pi3d.TextBlock(self.x,
self.y + 50,
0.1,
0.0,
2,
text_format="00",
size=0.6,
spacing="F",
space=0.02,
colour=(0.0, 0.0, 0.0, 1),
justify=1)
self.actval.add_text_block(self.temp_set)
self.dot2 = pi3d.Disk(radius=int(self.thickness / 2) + 3,
sides=30,
x=self.x,
y=self.y,
z=0.2,
rx=90,
camera=graphics.CAMERA)
self.dot2.set_shader(graphics.MATSH)
self.dot2.set_material((1, 1, 1))
self.dot2.set_alpha(0.8)
self.valuex = 0
self.changed = 0
def __init__(self,
angle_fr=-135,
angle_to=135,
step=5,
outer=240,
inner=200,
min_t=15,
max_t=35,
shader=None,
camera=None):
self.angle_fr = angle_fr
self.angle_to = angle_to
self.step = step
self.outer = outer
self.inner = inner
self.mid = (outer + inner) / 2
self.min_t = min_t
self.max_t = max_t
gpio.setmode(gpio.BCM)
gpio.setwarnings(False)
gpio.setup(26, gpio.IN, pull_up_down=gpio.PUD_DOWN)
self.bus = i2c.I2C(2)
try:
self.bus.read(1, 0x5c)
self.bus.write([0x6e, 0b00001110], 0x5c)
self.bus.write([0x70, 0b00000000], 0x5c)
except:
print('Error: no touchscreen found')
tick_verts = []
dial_verts = []
# first make tick vertices
for x in range(self.angle_fr, self.angle_to, self.step):
(s, c) = (sin(radians(x)), cos(radians(x))
) # re-use for brevity below
tick_verts.extend([(self.inner * s, self.inner * c, 0.1),
(self.outer * s, self.outer * c, 0.1)])
dial_verts.append((self.mid * s, self.mid * c, 2.0))
if shader is None:
shader = pi3d.Shader('mat_flat')
if camera is None:
camera = pi3d.Camera(is_3d=False)
uv_shader = pi3d.Shader('uv_flat')
tex = pi3d.Texture('color_gradient.jpg')
self.ticks = pi3d.PolygonLines(camera=camera,
vertices=tick_verts,
strip=False,
line_width=5)
self.ticks.set_shader(shader)
self.ticks.set_alpha(0.8)
self.sensorticks = pi3d.PolygonLines(camera=camera,
vertices=tick_verts,
line_width=5,
strip=False)
self.sensorticks.set_shader(shader)
self.bline = pi3d.PolygonLines(camera=camera,
vertices=dial_verts,
line_width=40)
self.bline.set_textures([tex])
self.bline.set_alpha(0.8)
self.bline.set_shader(uv_shader)
self.bline.set_material((0.5, 0.5, 0.5))
self.dial = pi3d.PolygonLines(camera=camera,
vertices=dial_verts,
line_width=8)
self.dial.set_alpha(0.2)
self.dial.set_shader(shader)
font = pi3d.Font('opensans.ttf',
codepoints='0123456789.-°',
grid_size=5)
self.actval = pi3d.PointText(font,
camera,
max_chars=10,
point_size=100)
self.temp_block = pi3d.TextBlock(0,
0,
0.1,
0.0,
6,
justify=0.5,
text_format="0°",
size=0.79,
spacing="F",
space=0.02,
colour=(1.0, 1.0, 1.0, 1.0))
self.actval.add_text_block(self.temp_block)
self.dot2 = pi3d.Disk(radius=20, sides=20, z=0.1, rx=90, camera=camera)
self.dot2.set_shader(shader)
self.dot2.set_material((1, 1, 1))
self.dot2_alpha = 1.0
self.value = 25.0
self.sensorvalue = 18.0
degree = (self.angle_fr + (self.angle_to - self.angle_fr) *
(self.value - self.min_t) / (self.max_t - self.min_t))
self.x1 = self.mid * sin(radians(degree))
self.y1 = self.mid * cos(radians(degree))
def __init__(self,
angle_fr=-140,
angle_to=140,
step=8,
x=0,
y=0,
outer=250,
inner=180,
min_v=15,
max_v=30,
text_format="{:4.1f}°",
set_field="set_temp",
act_field="act_temp",
shader=None,
camera=None):
self.angle_fr = angle_fr
self.angle_to = ((angle_to - angle_fr) // step + 1) * step + angle_fr
self.step = step
self.outer = outer
self.inner = inner
self.mid = (outer + inner) / 2
self.min_v = min_v
self.max_v = max_v
self.x = x
self.y = y
self.set_field = set_field
self.act_field = act_field
self.text_format = text_format
tick_verts = []
dial_verts = []
# first make tick vertices
for x2 in range(self.angle_fr, self.angle_to, self.step):
(s, c) = (sin(radians(x2)), cos(radians(x2))
) # re-use for brevity below
tick_verts.extend([(self.inner * s, self.inner * c, 0.1),
(self.outer * s, self.outer * c, 0.1)])
dial_verts.append((self.mid * s, self.mid * c, 2.0))
tex = pi3d.Texture(
resource_filename("shpi", "sprites/color_gradient.jpg"))
self.ticks = pi3d.PolygonLines(camera=graphics.CAMERA,
x=self.x,
y=self.y,
vertices=tick_verts,
strip=False,
line_width=8)
self.ticks.set_shader(graphics.MATSH)
self.ticks.set_alpha(0.8)
self.sensorticks = pi3d.PolygonLines(camera=graphics.CAMERA,
x=self.x,
y=self.y,
vertices=tick_verts,
line_width=8,
strip=False)
self.sensorticks.set_shader(graphics.MATSH)
self.bline = pi3d.PolygonLines(camera=graphics.CAMERA,
x=self.x,
y=self.y,
vertices=dial_verts,
line_width=80)
self.bline.set_textures([tex])
self.bline.set_alpha(0.8)
self.bline.set_shader(graphics.SHADER)
self.bline.set_material((0.5, 0.5, 0.5))
self.trian = pi3d.Triangle(camera=graphics.CAMERA,
x=self.x,
y=self.y,
z=0.1,
corners=((-15, self.inner - 20,
0), (0, self.inner + 5, 0),
(15, self.inner - 20, 0)))
self.trian.set_shader(graphics.MATSH)
self.trian.set_material((0.3, 0.1, 0))
self.trian.set_alpha(1)
self.dial = pi3d.PolygonLines(camera=graphics.CAMERA,
x=self.x,
y=self.y,
vertices=dial_verts,
line_width=84)
self.dial.set_alpha(0.2)
self.dial.set_shader(graphics.MATSH)
self.dial.set_material((0, 0, 0))
self.actval = pi3d.PointText(graphics.pointFont,
graphics.CAMERA,
max_chars=23,
point_size=100)
self.val_block = pi3d.TextBlock(self.x,
self.y + 10,
0.1,
0.0,
11,
justify=0.6,
text_format=text_format,
size=0.99,
spacing="F",
space=0.02,
colour=(1.0, 1.0, 1.0, 1.0))
self.actval.add_text_block(self.val_block)
self.value = getattr(peripherals.eg_object, self.set_field)
self.sensorvalue = getattr(peripherals.eg_object, self.act_field)
self.set_block = pi3d.TextBlock(0,
self.inner - 30,
0.1,
0,
11,
text_format=self.text_format.format(
self.value),
size=0.35,
spacing="F",
space=0.02,
colour=(1.0, 1.0, 1.0, 1),
justify=0.6)
self.actval.add_text_block(self.set_block)
self.dot1 = pi3d.Disk(radius=130,
sides=30,
x=self.x,
y=self.y,
z=2,
rx=90,
camera=graphics.CAMERA)
self.dot1.set_shader(graphics.MATSH)
self.dot1.set_material((0, 0, 0))
self.dot1.set_alpha(0.4)
self.dot2 = pi3d.Disk(radius=30,
sides=20,
x=self.x,
y=self.y,
z=0.1,
rx=90,
camera=graphics.CAMERA)
self.dot2.set_shader(graphics.MATSH)
self.dot2.set_material((1, 1, 1))
self.dot2_alpha = 1.0
self.degree = (self.angle_fr + (self.angle_to - self.angle_fr) *
(self.value - self.min_v) / (self.max_v - self.min_v))
self.trian.rotateToZ(-self.degree + self.step)
if self.sensorvalue < self.min_v:
self.sensorvalue = self.min_v
if self.sensorvalue > self.max_v:
self.sensorvalue = self.max_v
self.sensordegree = (self.angle_fr + (self.angle_to - self.angle_fr) *
(self.sensorvalue - self.min_v) /
(self.max_v - self.min_v))
self.x1 = self.mid * sin(radians(self.degree)) + self.x
self.y1 = self.mid * cos(radians(self.degree)) + self.y
self.changed = 0
self.dot2.position(self.x1, self.y1, 0.5)
self.dot2_alpha = 1.0
self.set_block.set_position(
x=(self.inner - 33) * sin(radians(self.degree - self.step)) +
self.x,
y=(self.inner - 33) * cos(radians(self.degree - self.step)) +
self.y,
rot=-self.degree + self.step)