def draw_paddle(self, screen, offset, paddle):
if paddle != None:
rect = sdl2.SDL_Rect(int((paddle.pos[0] - offset) * screen.height),
int(paddle.pos[1] * screen.height),
int(paddle.size[0] * screen.height),
int(paddle.size[1] * screen.height))
sdl2.SDL_RenderFillRect(screen.renderer.sdlrenderer, rect)
def draw_rects(renderer):
global current_alpha, current_color, cycle_direction
rect = sdl2.SDL_Rect()
viewport = sdl2.SDL_Rect()
sdl2.SDL_RenderGetViewport(renderer, ctypes.byref(viewport))
for i in range(0, NUM_OBJECTS):
current_color = current_color + cycle_direction
if current_color < 0:
current_color = 0
cycle_direction = -cycle_direction
if current_color > 255:
current_color = 255
cycle_direction = -cycle_direction
sdl2.SDL_SetRenderDrawColor(renderer, 255, current_color,
current_color, current_alpha)
rect.w = (int(random.random() * 65535) % int(viewport.h / 2))
rect.h = (int(random.random() * 65535) % int(viewport.h / 2))
rect.x = ((int(random.random() * 65535) %
(viewport.w * 2)) - viewport.w) - int(rect.w / 2)
rect.y = ((int(random.random() * 65535) %
(viewport.h * 2)) - viewport.h) - int(rect.h / 2)
sdl2.SDL_RenderFillRect(renderer, ctypes.byref(rect))
def draw_ball(self, screen, offset, ball):
if ball != None:
rect = sdl2.SDL_Rect(int((ball.pos[0] - offset) * screen.height),
int(ball.pos[1] * screen.height),
int(ball.size[0] * screen.height),
int(ball.size[1] * screen.height))
sdl2.SDL_RenderFillRect(screen.renderer.sdlrenderer, rect)
def draw_apple(game, renderer):
global cell_size
x = int(game.apple.x * cell_size + cell_size / 4)
y = int(game.apple.y * cell_size + cell_size / 4)
size = int(cell_size / 2)
rect = sdl2.SDL_Rect(x, y, size, size)
sdl2.SDL_SetRenderDrawColor(renderer, 255, 0, 0, 0)
sdl2.SDL_RenderFillRect(renderer, rect)
def render_npcs(self, renderer, screen_width, screen_height, entities):
sdl2.SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255)
for character in entities.characters:
sdl2.SDL_RenderFillRect(
renderer,
sdl2.SDL_Rect(self.get_adjusted_x(character, screen_width),
self.get_adjusted_y(character, screen_height),
MiniMap.character_dot_size,
MiniMap.character_dot_size))
def fill_color(self, color=None):
if color is not None:
tmp = self.color
self.color = color
ret = sdl2.SDL_RenderFillRect(self.sdlrenderer, None)
if color is not None:
self.color = tmp
if ret == -1:
raise sdl2.ext.SDLError()
def paint_rectangle(self, x, y, w, h):
"""
Paints the whole rectangle on the screen. (It will be filled).
To only draw its outline, use the `sketch_rectangle` method.
"""
x, y = self.transform[-1].position(x, y)
w, h = self.transform[-1].size(w, h)
rect = sdl2.SDL_Rect(int(x), int(y), int(w), int(h))
sdl2.SDL_RenderFillRect(self.renderer, rect)
def render_locations(self, renderer, screen_width, screen_height,
entities):
sdl2.SDL_SetRenderDrawColor(renderer, 80, 80, 80, 255)
for location in entities.locations:
sdl2.SDL_RenderFillRect(
renderer,
sdl2.SDL_Rect(self.get_adjusted_x(location, screen_width),
self.get_adjusted_y(location, screen_height),
int(location.width * self.x_scale),
int(location.height * self.y_scale)))
def render_player(self, renderer, screen_width, screen_height, entities):
sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255)
sdl2.SDL_RenderFillRect(
renderer,
sdl2.SDL_Rect(
int(
self.get_adjusted_x(entities.player, screen_width) -
MiniMap.player_dot_size / 2),
int(
self.get_adjusted_y(entities.player, screen_height) -
MiniMap.player_dot_size / 2), MiniMap.player_dot_size,
MiniMap.player_dot_size))
def render_roads(self, renderer, screen_width, screen_height, entities):
sdl2.SDL_SetRenderDrawColor(renderer, 48, 48, 48, 255)
for road in entities.map_elements:
if road.type != MapElementType.ROAD:
continue
sdl2.SDL_RenderFillRect(
renderer,
sdl2.SDL_Rect(self.get_adjusted_x(road, screen_width),
self.get_adjusted_y(road, screen_height),
int(road.width * self.x_scale),
int(road.height * self.y_scale)))
def fillRect(self, x, y, w, h):
''' Рисует залитый прямоугольник
* @param {number} x - Координата X левого верхнего угла
* @param {number} y - Координата Y левого верхнего угла
* @param {number} w - Ширина
* @param {number} h - Высота
* @returns {self}
'''
rect = SDL.SDL_Rect(int(x), int(y), int(w), int(h))
SDL.SDL_RenderDrawRect(self.ctx, rect)
SDL.SDL_RenderFillRect(self.ctx, rect)
return self
def draw_score(self, screen, scores):
size = 20
offset = 0
for score in map(bitfont, scores):
side = offset == 0
offset = self.from_center(screen, len(score), size, side)
for digit in score:
offset_x = offset
offset_y = size
for i in range(len(digit)):
if i > 0 and i % 3 == 0:
offset_y += size
offset_x = offset
if digit[i]:
rect = sdl2.SDL_Rect(offset_x, offset_y, size, size)
sdl2.SDL_RenderFillRect(screen.renderer.sdlrenderer,
rect)
offset_x += size
offset = offset_x + size
offset += 2 * size
def updown_render(screen,
scrno,
data,
colours=[(96, 210, 255, 255), (200, 200, 200, 255),
(200, 000, 000, 255)]):
width, height = screen.dimensions
sect_width = width / len(data[0]) * scrno
bars_each = int(len(data[0]) / scrno)
screen.setcolour(colours[0])
for i, channel in enumerate(data):
for j, datum in enumerate(channel[screen.n * bars_each:(screen.n + 1) *
bars_each]):
screen.setcolour(
colours[j % 2 if sect_width > RECOMMENDED_WIDTH else 0])
bar = sdl2.SDL_Rect(
int(j * sect_width), height // 2,
int(sect_width) + 1,
int((-1)**i * datum * height // 2 // SCALE_DOWN))
sdl2.SDL_RenderFillRect(screen.sdlrenderer, bar)
screen.setcolour(colours[2])
sdl2.SDL_RenderDrawLine(screen.sdlrenderer, 0, height // 2, width,
height // 2)
def fill(renderer, x0, y0, x1, y1):
rect = sdl2.SDL_Rect(x0, y0, x1 - x0, y1 - y0)
sdl2.SDL_RenderFillRect(renderer, rect)
def rect_on(display, rect, r, g, b, a):
renderer = App.windows[display]["renderer"]
sdl2.SDL_SetRenderDrawColor(renderer, r, g, b, a)
sdl2.SDL_RenderFillRect(renderer, rect)
def main():
sdl2.sdl2_load(
ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib'
ttf_libpath=ctypes.util.find_library('SDL2_ttf'))
sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING)
WINDOW_W = 640
WINDOW_H = 360
window = sdl2.SDL_CreateWindow(b"Minimal SDL_TTF Test via python-sdl2", 0,
0, WINDOW_W, WINDOW_H,
sdl2.SDL_WINDOW_OPENGL)
renderer = sdl2.SDL_CreateRenderer(window, -1, 0)
rect = sdl2.SDL_Rect()
rect.x = 0
rect.y = 0
rect.w = WINDOW_W
rect.h = WINDOW_H
sdl2.TTF_Init()
rwops_ptr = sdl2.SDL_RWFromFile(
bytes(sys.argv[1], 'utf-8'), b"rb"
) # rwops = ctypes.cast(rwops_ptr, ctypes.POINTER(sdl2.SDL_RWops)).contents
font = sdl2.TTF_OpenFontRW(rwops_ptr, 0, 42)
fg = sdl2.SDL_Color()
fg.r = 96
fg.g = 96
fg.b = 96
fg.a = 255
bg = sdl2.SDL_Color()
bg.r = 0xE0
bg.g = 0xE0
bg.b = 0xE0
bg.a = 255
pos = [
sdl2.SDL_Rect(),
sdl2.SDL_Rect(),
]
pos[0].x = 20
pos[0].y = 120
pos[0].w = 600
pos[0].h = 60
pos[1].x = 20
pos[1].y = 180
pos[1].w = 600
pos[1].h = 60
surfaces = [
sdl2.TTF_RenderUTF8_Shaded(font, bytes("志於道、據於徳、依於仁、游於藝", 'utf-8'), fg,
bg),
sdl2.TTF_RenderUTF8_Shaded(font, bytes("ＳＣＯＲＥ １２３４５６７８０", 'utf-8'), fg,
bg),
]
texture = [
sdl2.SDL_CreateTextureFromSurface(renderer, surfaces[0]),
sdl2.SDL_CreateTextureFromSurface(renderer, surfaces[1]),
]
sdl2.SDL_SetRenderDrawColor(renderer, bg.r, bg.g, bg.b, bg.a)
sdl2.SDL_RenderFillRect(renderer, ctypes.byref(rect))
sdl2.SDL_RenderCopy(renderer, texture[0], None, ctypes.byref(pos[0]))
sdl2.SDL_RenderCopy(renderer, texture[1], None, ctypes.byref(pos[1]))
sdl2.SDL_RenderPresent(renderer)
sdl2.SDL_FreeSurface(surfaces[0])
sdl2.SDL_FreeSurface(surfaces[1])
fpsdelay = 100
count = 0
event = sdl2.SDL_Event()
done = False
while not done:
while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0:
# 'type' and 'timestamp' are common members for all SDL Event structs.
event_type = event.common.type
event_timestamp = event.common.timestamp
# print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) )
if event_type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
done = True
sdl2.SDL_Delay(fpsdelay)
sdl2.TTF_Quit()
sdl2.SDL_DestroyRenderer(renderer)
sdl2.SDL_DestroyWindow(window)
sdl2.SDL_Quit()
def draw_board(wsize, renderer):
rect = sdl2.SDL_Rect(0, 0, wsize, wsize)
sdl2.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0)
sdl2.SDL_RenderFillRect(renderer, rect)
