SDL3_image - не отрисовывается текстура

# pip install Box2D Pygame
 
import math
 
import pygame
from Box2D import (b2_dynamicBody, b2_kinematicBody, b2_staticBody, b2BodyDef,
                   b2ContactListener, b2FixtureDef, b2PolygonShape, b2Vec2,
                   b2World)
 
from debug_drawer import DebugDrawer
 
 
class ContactListener(b2ContactListener):
 
    def BeginContact(self, contact):
        userDataA = contact.fixtureA.userData
        userDataB = contact.fixtureB.userData
        print(userDataA["name"], "<--->", userDataB["name"])
 
def main():
 
    pygame.init()
 
    # Create a window of a given size with a title
    window = pygame.display.set_mode((268, 268))
    pygame.display.set_caption("PyBox2D and Pygame")
 
    # Create a physical world with zero gravity
    gravity=b2Vec2(0, 0)
    world = b2World(gravity)
 
    # The size of the physical world must be between 0.1 and 10
    # so a constant pixelsPerMeter is created to
    # translate from the pixel world to the Box2D physical world
    pixelsPerMeter = 30
 
    # Create DebugDrawer and configure it
    debugDrawer = DebugDrawer(window, pixelsPerMeter)
    debugDrawer.flags = { "drawShapes": True }
    world.renderer = debugDrawer
 
    # Create a ContactListener
    world.contactListener = ContactListener()
 
    # Creating a player body
    playerBodyDef = b2BodyDef() # Object for setting the position and type of the object
    # Set player position and type
    playerBodyDef.position = b2Vec2(200 / pixelsPerMeter, 100 / pixelsPerMeter)
    playerBodyDef.type = b2_dynamicBody
    # Prevent player from spinning
    playerBodyDef.fixedRotation = True
    # Create a player body
    playerBody = world.CreateBody(playerBodyDef)
    # The player must not fall asleep
    playerBody.sleepingAllowed = False
    # Create a player shape in the form of a rectangle
    playerShape = b2PolygonShape()
    playerShape.SetAsBox(10 / pixelsPerMeter, 20 / pixelsPerMeter)
    # Linking the player's body and form
    playerFixtureDef = b2FixtureDef()
    playerFixtureDef.shape = playerShape
    # Player density. This is analogous to mass
    playerFixtureDef.density = 1
    playerFixture = playerBody.CreateFixture(playerFixtureDef)
    playerFixture.userData = { "name": "player" }
 
    # Create a wall similar to the player, but now
    # the body type is static and density = 0
    wallBodyDef = b2BodyDef()
    # Set the position and type of the wall
    wallBodyDef.position = b2Vec2(100 / pixelsPerMeter, 150 / pixelsPerMeter)
    wallBodyDef.type = b2_staticBody
    wallBodyDef.angle = math.radians(30)
    # Create the body of the wall
    wallBody = world.CreateBody(wallBodyDef)
    # Create a player shape in the form of a rectangle
    wallShape = b2PolygonShape()
    wallShape.SetAsBox(10 / pixelsPerMeter, 50 / pixelsPerMeter)
    # Combine wall body and shape
    wallFixtureDef = b2FixtureDef()
    wallFixtureDef.shape = wallShape
    # Wall density. This is analogous to mass.
    wallFixtureDef.density = 0
    wallFixture = wallBody.CreateFixture(wallFixtureDef)
    wallFixture.userData = { "name": "wall" }
 
    # Create a kinematic fan
    # with a static body and density = 0
    fanBodyDef = b2BodyDef()
    # Set the position and type of the fan
    fanBodyDef.position = b2Vec2(200 / pixelsPerMeter, 200 / pixelsPerMeter)
    fanBodyDef.type = b2_kinematicBody
    fanBodyDef.angle = math.radians(0)
    # Create the body of the fan
    fanBody = world.CreateBody(fanBodyDef)
    # Create a rectangular fan shape
    fanShape = b2PolygonShape()
    fanShape.SetAsBox(5 / pixelsPerMeter, 30 / pixelsPerMeter)
    # Connect the fan body and the shape
    fanFixtureDef = b2FixtureDef()
    fanFixtureDef.shape = fanShape
    # Fan density. This is analogous to mass.
    fanFixtureDef.density = 0
    fanFixture = fanBody.CreateFixture(fanFixtureDef)
    fanFixture.userData = { "name": "fan" }
 
    # Dictionary for storing pressed keys
    keys = { "left": False, "right": False, "up": False, "down": False }
 
    clock = pygame.time.Clock()
    playerSpeed = 5
    fanSpeed = 180
 
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            if event.type == pygame.KEYDOWN:
                key = pygame.key.name(event.key)
                keys[key] = True
            if event.type == pygame.KEYUP:
                key = pygame.key.name(event.key)
                keys[key] = False
 
        if keys["left"]:
            playerBody.linearVelocity.x = -playerSpeed
        if keys["right"]:
            playerBody.linearVelocity.x = playerSpeed
        if keys["up"]:
            playerBody.linearVelocity.y = -playerSpeed
        if keys["down"]:
            playerBody.linearVelocity.y = playerSpeed
 
        # Set the number of frames per second (60) and
        # calculate the time interval between frames dt (~0.16)
        dt = clock.tick(60) / 1000
 
        # Set the angle of the fan
        fanBody.angle += math.radians(fanSpeed * dt)
 
        # Take physics simulation one step further
        world.Step(dt, 3, 2)
 
        # Stop the player
        playerBody.linearVelocity = b2Vec2(0, 0)
 
        # Fill the screen with black color
        window.fill(0)
 
        # Drawing colliders
        world.DrawDebugData()
 
        # Updating the display
        pygame.display.flip()
 
if __name__ == '__main__':
    main()

import math
 
import pygame
from Box2D import b2Draw
 
 
class DebugDrawer(b2Draw):
 
    def __init__(self, window, pixelsPerMeter, thickness=3):
        super().__init__()
        self.window = window
        self.pixelsPerMeter = pixelsPerMeter
        self.thickness = thickness
 
    def DrawSolidPolygon(self, vertices, color):
        pygame.draw.line(self.window, (color.r * 255, color.g * 255, color.b * 255),
            (vertices[0][0] * self.pixelsPerMeter, vertices[0][1] * self.pixelsPerMeter),
            (vertices[1][0] * self.pixelsPerMeter, vertices[1][1] * self.pixelsPerMeter),
            self.thickness)
        pygame.draw.line(self.window, (color.r * 255, color.g * 255, color.b * 255),
            (vertices[1][0] * self.pixelsPerMeter, vertices[1][1] * self.pixelsPerMeter),
            (vertices[2][0] * self.pixelsPerMeter, vertices[2][1] * self.pixelsPerMeter),
            self.thickness)
        pygame.draw.line(self.window, (color.r * 255, color.g * 255, color.b * 255),
            (vertices[2][0] * self.pixelsPerMeter, vertices[2][1] * self.pixelsPerMeter),
            (vertices[3][0] * self.pixelsPerMeter, vertices[3][1] * self.pixelsPerMeter),
            self.thickness)
        pygame.draw.line(self.window, (color.r * 255, color.g * 255, color.b * 255),
            (vertices[3][0] * self.pixelsPerMeter, vertices[3][1] * self.pixelsPerMeter),
            (vertices[0][0] * self.pixelsPerMeter, vertices[0][1] * self.pixelsPerMeter),
            self.thickness)
 
    def DrawSolidCircle(self, center, radius, axis, color):
        pass
    def DrawPolygon(self, vertices, color):
        pass
    def DrawSegment(self, p1, p2, color):
        pass
    def DrawPoint(self, p, size, color):
        pass
    def DrawCircle(self, center, radius, color, drawwidth=1):
        pass
    def DrawTransform(self, xf):
        pass

import ctypes
import os
import time
from random import randint
 
os.environ["SDL_MAIN_USE_CALLBACKS"] = "1"
 
import sdl3
 
renderer = ctypes.POINTER(sdl3.SDL_Renderer)()
window = ctypes.POINTER(sdl3.SDL_Window)()
 
windowWidth = 400
windowHeight = 400
 
snake = [(20, 20)] # Snake list of (x, y) positions
snakeDir = (10, 0) # Snake movement direction
 
interval = 0.2 # update interval in milliseconds
keyFrameTime = 0
lastTime = 0
 
keys = { "left": False, "right": False, "up": False, "down": False }
 
food = [] # Food list of type (x, y)
 
def vecAdd(v1, v2):
    return (v1[0] + v2[0], v1[1] + v2[1])
 
@sdl3.SDL_AppInit_func
def SDL_AppInit(appstate, argc, argv):
    global windowWidth
    global windowHeight
 
    if not sdl3.SDL_Init(sdl3.SDL_INIT_VIDEO):
        sdl3.SDL_Log("Couldn't initialize SDL: %s", sdl3.SDL_GetError())
        return sdl3.SDL_APP_FAILURE
 
    if not sdl3.SDL_CreateWindowAndRenderer("Snake NoobTuts".encode(), windowWidth, windowHeight, 0, window, renderer):
        sdl3.SDL_Log("Couldn't create window/renderer: %s", sdl3.SDL_GetError())
        return sdl3.SDL_APP_FAILURE
 
    sdl3.SDL_SetRenderVSync(renderer, 1) # Turn on vertical sync
 
    return sdl3.SDL_APP_CONTINUE
 
@sdl3.SDL_AppEvent_func
def SDL_AppEvent(appstate, event):
    if sdl3.SDL_DEREFERENCE(event).type == sdl3.SDL_EVENT_QUIT:
        return sdl3.SDL_APP_SUCCESS
    elif sdl3.SDL_DEREFERENCE(event).type == sdl3.SDL_EVENT_KEY_DOWN:
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_W or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_UP:
            keys["up"] = True
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_S or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_DOWN:
            keys["down"] = True
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_A or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_LEFT:
            keys["left"] = True
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_D or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_RIGHT:
            keys["right"] = True
    elif sdl3.SDL_DEREFERENCE(event).type == sdl3.SDL_EVENT_KEY_UP:
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_W or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_UP:
            keys["up"] = False
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_S or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_DOWN:
            keys["down"] = False
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_A or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_LEFT:
            keys["left"] = False
        if sdl3.SDL_DEREFERENCE(event).key.scancode == sdl3.SDL_SCANCODE_D or sdl3.SDL_DEREFERENCE(event).button.button == sdl3.SDL_SCANCODE_RIGHT:
            keys["right"] = False
 
    return sdl3.SDL_APP_CONTINUE
 
def keyboard():
    global snakeDir # important if we want to set it to a new value
 
    if keys["up"]:
        snakeDir = (0, -10)
    if keys["down"]:
        snakeDir = (0, 10)
    if keys["left"]:
        snakeDir = (-10, 0)
    if keys["right"]:
        snakeDir = (10, 0)
 
@sdl3.SDL_AppIterate_func
def SDL_AppIterate(appstate):
    global interval
    global lastTime
    global keyFrameTime
    global snake
    global snakeDir
 
    # As you can see from this, rendering draws over whatever was drawn before it
    sdl3.SDL_SetRenderDrawColor(renderer, 33, 33, 33, sdl3.SDL_ALPHA_OPAQUE)
    sdl3.SDL_RenderClear(renderer) # Start with a blank canvas
 
    keyboard();
 
    currentTime = sdl3.SDL_GetTicks()
    deltaTime = (currentTime - lastTime) / 1000
    lastTime = currentTime
 
    # Game tick
    keyFrameTime += deltaTime
    if keyFrameTime > interval:
        # Insert new position in the beginning of the snake list
        snake.insert(0, vecAdd(snake[0], snakeDir))
        # Remove the last element
        snake.pop()
 
        # Spawn food
        r = randint(0, 20) # Spawn food with 5% chance
        if r == 0:
            # Random spawn position
            x = randint(0, int(windowWidth / 10)) * 10
            y = randint(0, int(windowHeight / 10)) * 10
            food.append((x, y))
            print("spawn food:", x, y)
 
        # Let the snake eat the food
        (hx, hy) = snake[0]          # Get the snake's head x and y position
        for x, y in food:            # Go through the food list
            if hx == x and hy == y:  # Is the head where the food is?
                snake.append((x, y)) # Make the snake longer
                food.remove((x, y))  # Remove the food
 
        # Start a new frame
        keyFrameTime = 0
 
    rect = sdl3.SDL_FRect()
    rect.w = 10
    rect.h = 10
 
    # Draw a food
    sdl3.SDL_SetRenderDrawColor(renderer, 128, 128, 255, sdl3.SDL_ALPHA_OPAQUE)
    for x, y in food:
        rect.x = x
        rect.y = y
        sdl3.SDL_RenderFillRect(renderer, rect)
 
    # Draw a snake
    sdl3.SDL_SetRenderDrawColor(renderer, 255, 255, 255, sdl3.SDL_ALPHA_OPAQUE)
    for x, y in snake:
        rect.x = x
        rect.y = y
        sdl3.SDL_RenderFillRect(renderer, rect)
 
    sdl3.SDL_RenderPresent(renderer)
    return sdl3.SDL_APP_CONTINUE
 
@sdl3.SDL_AppQuit_func
def SDL_AppQuit(appstate, result):
    ... # SDL will clean up the window/renderer for us.