|
런타임(디버그)에 collision shape이 표시되도록 해 보자.
| [Godot] CharacterBody2D Inertial Motion 캐릭터 관성 운동 (0) | 2024.02.15 |
|---|---|
| [Godot] 2D Splash Dynamic Wave 자연스러운 물결 파동 3. 응용 (0) | 2024.02.11 |
| [Godot] Crashes/Freezes When Opening Project Settings (1) | 2023.12.03 |
| [Godot] Bezier Spline Curve 베지어 스플라인 곡선 (0) | 2023.10.21 |
| [Godot] 2D Splash Dynamic Wave 자연스러운 물결 파동 2. 구현 (0) | 2023.10.18 |
중력이 적용된 캐릭터를 만들어 보자.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
import pygame
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480), vsync=1)
clock = pygame.time.Clock()
FPS = 60
running = True
# 플레이어 클래스 with Gravity
class Player(pygame.sprite.Sprite):
def __init__(self, position):
pygame.sprite.Sprite.__init__(self)
self.direction = -1
self.speed = 4
self.image = pygame.image.load("player.png").convert()
self.image.set_colorkey(self.image.get_at((0, 0)))
self.size = (self.image.get_width()*1.5, self.image.get_height()*1.5)
self.image = pygame.transform.scale(self.image, self.size)
self.rect = self.image.get_rect(center=position)
self.isGround = False
self.jumpForce = 0.0
self.gravity = 5.0
def flip_image(self):
self.image = pygame.transform.flip(self.image, True, False)
def update(self):
global running
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
running = False
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
if self.direction > 0:
self.flip_image()
self.direction = -1
self.rect.move_ip(-self.speed, 0)
if keys[pygame.K_RIGHT]:
if self.direction < 0:
self.flip_image()
self.direction = 1
self.rect.move_ip(self.speed, 0)
if keys[pygame.K_UP]:
if self.isGround:
self.jumpForce = -17
if not self.isGround:
self.rect.centery += self.gravity + self.jumpForce
self.gravity += 0.3
else:
self.rect.centery += self.jumpForce
self.gravity = 5.0
if self.jumpForce < 0:
self.jumpForce += 0.10
elif self.jumpForce >= 0:
self.jumpForce = 0.0
# 버블 클래스
class Bubble(pygame.sprite.Sprite):
def __init__(self, position):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.image.load("bubble.png").convert()
self.image.set_colorkey(self.image.get_at((0, 0)))
self.size = (self.image.get_width()*6, self.image.get_height()*6)
self.image = pygame.transform.scale(self.image, self.size)
self.rect = self.image.get_rect(center=position)
self.collided = False
def update(self):
if self.collided == True:
self.rect.top -= 1
# 그라운드 클래스
class Ground(pygame.sprite.Sprite):
def __init__(self, position):
pygame.sprite.Sprite.__init__(self)
self.image = pygame.image.load("ground.png").convert()
self.rect = self.image.get_rect(bottomleft=position)
def update(self):
pass
def main():
player = Player((screen.get_width()/2, screen.get_height()/2))
player_sprite = pygame.sprite.Group(player)
# 플레이어 스프라이트 그룹
bubbles = [
Bubble((40, screen.get_height()/2)),
Bubble((160, screen.get_height()/2)),
Bubble((480, screen.get_height()/2)),
Bubble((600, screen.get_height()/2))]
bubble_sprites = pygame.sprite.Group(bubbles)
# 버블 스프라이트 그룹
grounds = [
Ground((0, 480)),
Ground((440, 480))]
ground_sprites = pygame.sprite.Group(grounds)
all_sprites = pygame.sprite.Group()
all_sprites.add(player_sprite)
all_sprites.add(bubble_sprites)
all_sprites.add(ground_sprites)
while running:
#player_sprite.update()
#bubble_sprites.update()
all_sprites.update()
collision = pygame.sprite.spritecollide(player, bubble_sprites, False)
for bubble in collision:
bubble.collided = True
# 플레이어와 버블의 충돌을 감지하고 충돌한 버블의 collided 값을 True로 바꾼다.
collision = pygame.sprite.spritecollide(player, ground_sprites, False)
if len(collision) != 0:
player.isGround = True
player.jumpForce = 0.0
player.rect.bottom = collision[0].rect.top
else:
player.isGround = False
screen.fill("black")
#player_sprite.draw(screen)
#bubble_sprites.draw(screen)
#ground_sprites.draw(screen)
all_sprites.draw(screen)
pygame.display.flip()
clock.tick(FPS)
pygame.quit()
if __name__ == '__main__':
main()
|
코드를 입력하고 실행한다.
| [Pygame] Sorting Algorithms in Python 파이썬 정렬 알고리즘 2 (0) | 2024.03.22 |
|---|---|
| [Pygame] Sorting Algorithms in Python 파이썬 정렬 알고리즘 1 (0) | 2024.03.09 |
| [Pygame] Pygame Simple Camera 파이게임 간단한 카메라 (0) | 2024.02.02 |
| [Pygame] Pygame GUI 파이게임 그래픽 유저 인터페이스 (0) | 2024.01.29 |
| [Pygame] Box2D 파이게임 물리 라이브러리 (0) | 2024.01.28 |
파이게임에 간단한 카메라를 만들어 보자.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
import pygame
pygame.init()
pygame.display.set_caption("Pygame Simple Camera")
screen = pygame.display.set_mode((640, 480), flags=pygame.RESIZABLE, vsync=1)
clock = pygame.time.Clock()
class Camera():
def __init__(self):
self.offset = pygame.math.Vector2(0, 0)
self.speed = 4
camera = Camera()
def LoadImage(path, scale=None, colorkey=None):
image = pygame.image.load(path).convert()
if scale is not None:
image = pygame.transform.scale(image, (image.get_width()*scale, image.get_height()*scale))
if colorkey is not None:
if colorkey == -1:
colorkey = image.get_at((0, 0))
image.set_colorkey(colorkey)
return image
class Sprite(pygame.sprite.Sprite):
def __init__(self, spriteName, position, frames):
pygame.sprite.Sprite.__init__(self)
self.elapsedTime = 0
self.limitTime = 1000/frames
# 1초에 한 사이클. 스프라이트가 8프레임이라면 frames에 8을 대입한다.
self.direction = 1
self.speed = 4
self.index = 0
self.images = [ LoadImage(spriteName, 3, -1) ]
self.image = self.images[self.index]
self.rect = self.image.get_rect(center=position)
def flip_image(self):
self.images = [pygame.transform.flip(image, True, False) for image in self.images]
self.image = self.images[self.index]
def update(self):
if (camera.offset.x != 0 or camera.offset.y != 0):
self.rect.move_ip(camera.offset.x, camera.offset.y)
# 1초에 frame번 image 업데이트.
# self.elapsedTime += clock.get_time()
# if self.elapsedTime < self.limitTime:
# pass
# else:
# self.elapsedTime = 0
# self.index += 1
# if self.index >= len(self.images):
# self.index = 0
# self.image = self.images[self.index]
def main():
player = Sprite("character.bmp", (screen.get_width()/2, screen.get_height()/2), 1)
shop = Sprite("shop.bmp", (screen.get_width()/2, screen.get_height()/2), 1)
all_sprites = pygame.sprite.Group()
all_sprites.add(shop)
all_sprites.add(player)
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
running = False
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
if player.direction > 0:
player.flip_image()
player.direction = -1
player.rect.move_ip(-player.speed, 0)
if keys[pygame.K_RIGHT]:
if player.direction < 0:
player.flip_image()
player.direction = 1
player.rect.move_ip(player.speed, 0)
if keys[pygame.K_UP]:
if player.direction < 0:
player.flip_image()
player.direction = 1
player.rect.move_ip(0, -player.speed)
if keys[pygame.K_DOWN]:
if player.direction < 0:
player.flip_image()
player.direction = 1
player.rect.move_ip(0, player.speed)
# 카메라 이동
if keys[pygame.K_a]:
camera.offset.x = camera.speed
if keys[pygame.K_d]:
camera.offset.x = -camera.speed
if keys[pygame.K_w]:
camera.offset.y = camera.speed
if keys[pygame.K_s]:
camera.offset.y = -camera.speed
all_sprites.update()
# 스프라이트 업데이트 후 카메라 오프셋 초기화
camera.offset.x = camera.offset.y = 0
screen.fill("black")
all_sprites.draw(screen)
pygame.display.flip()
clock.tick(60)
pygame.quit()
if __name__ == '__main__':
main()
|
코드를 입력하고 실행한다. set_mode()에 vsync 파라미터를 1로 설정하지 않으면 스프라이트가 움직일때 screen tearing 현상이 일어날 수 있다.
pygame.display.set_mode(..., vsync=1)
※ 참고
| [Pygame] Sorting Algorithms in Python 파이썬 정렬 알고리즘 1 (0) | 2024.03.09 |
|---|---|
| [Pygame] Pygame Gravity 파이게임 중력 (0) | 2024.02.03 |
| [Pygame] Pygame GUI 파이게임 그래픽 유저 인터페이스 (0) | 2024.01.29 |
| [Pygame] Box2D 파이게임 물리 라이브러리 (0) | 2024.01.28 |
| pypdf Splitting, Merging, Cropping, and Transforming the Pages of PDF File 파이썬 PDF 파일 분할, 병합, 자르기, 회전(변형) (1) | 2024.01.06 |
SDL에 2D 카메라를 만들어 보자.
character.bmp
0.00MB
shop.bmp
0.03MB
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
#include "SDL.h"
class Camera {
public:
int m_width;
int m_height;
int m_cameraBorder;
int m_target_width;
int m_target_height;
float m_x, m_y;
SDL_Texture* m_targetTexture;
public:
Camera(SDL_Renderer* renderer, int width, int height, int border, SDL_BlendMode mode) {
m_width = width;
m_height = height;
m_cameraBorder = border;
m_target_width = width + border * 2;
m_target_height = height + border * 2;
m_x = 0;
m_y = 0;
m_targetTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET,
m_target_width, m_target_height);
SDL_SetTextureBlendMode(m_targetTexture, mode);
}
void Draw(SDL_Renderer* renderer, int windowHeight) {
float pixel_h = (float)windowHeight / m_height;
float correction_x = (int)m_x - m_x;
float correction_y = (int)m_y - m_y;
SDL_Rect dst = { (int)(correction_x * pixel_h - pixel_h * m_cameraBorder),
(int)(correction_y * pixel_h - pixel_h * m_cameraBorder),
(int)(m_target_width * pixel_h),
(int)(m_target_height * pixel_h) };
SDL_RenderCopy(renderer, m_targetTexture, NULL, &dst);
}
void Update(int xDirection, int yDirection) {
m_x += 0.5f * xDirection;
m_y += 0.5f * yDirection;
}
void CameraReset(SDL_Renderer* renderer, int width, int height, int border, SDL_BlendMode mode) {
m_width = width;
m_height = height;
m_cameraBorder = border;
m_target_width = width + border * 2;
m_target_height = height + border * 2;
SDL_DestroyTexture(m_targetTexture);
m_targetTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET,
m_target_width, m_target_height);
SDL_SetTextureBlendMode(m_targetTexture, mode);
}
~Camera() {
SDL_DestroyTexture(m_targetTexture);
}
};
class Sprite {
public:
int width;
int height;
float m_destX, m_destY;
SDL_Surface* surface;
SDL_Texture* texture;
public:
Sprite(SDL_Renderer* renderer, const char* filename) {
surface = SDL_LoadBMP(filename);
width = surface->w;
height = surface->h;
m_destX = 0;
m_destY = 0;
texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_FreeSurface(surface);
}
void DrawSprite(SDL_Renderer* renderer, Camera* camera, int x, int y) {
SDL_Rect destRect = { (int)(m_destX - camera->m_x) + camera->m_cameraBorder + x,
(int)(m_destY - camera->m_y) + camera->m_cameraBorder + y,
width, height };
SDL_RenderCopy(renderer, texture, NULL, &destRect);
}
~Sprite() {
SDL_DestroyTexture(texture);
}
};
int main(int argc, char** argv) {
const int Window_Width = 640;
const int Window_Height = 480;
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS);
SDL_Window* window = SDL_CreateWindow("SDL Simple Camera", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, Window_Width, Window_Height, SDL_WINDOW_RESIZABLE);
SDL_assert(window);
SDL_SetHint(SDL_HINT_RENDER_BATCHING, "1");
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED |
SDL_RENDERER_PRESENTVSYNC);
SDL_assert(renderer);
// Init
Camera camera = Camera(renderer, 160, 120, 1, SDL_BLENDMODE_BLEND);
SDL_assert(camera.m_targetTexture);
Sprite shopSprite = Sprite(renderer, "shop.bmp");
Sprite characterSprite = Sprite(renderer, "character.bmp");
int xDirection = 0;
int yDirection = 0;
SDL_Event event;
bool quit = false;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE)
quit = true;
if (event.key.keysym.sym == SDLK_LEFT)
xDirection = -1;
if (event.key.keysym.sym == SDLK_RIGHT)
xDirection = 1;
if (event.key.keysym.sym == SDLK_UP)
yDirection = -1;
if (event.key.keysym.sym == SDLK_DOWN)
yDirection = 1;
if (event.key.keysym.sym == SDLK_r)
camera.CameraReset(renderer, 160, 120, 1, SDL_BLENDMODE_BLEND);
if (event.key.keysym.sym == SDLK_e)
camera.CameraReset(renderer, 640, 480, 1, SDL_BLENDMODE_BLEND);
break;
default:
xDirection = 0;
yDirection = 0;
break;
}
}
camera.Update(xDirection, yDirection);
// Camera target
SDL_SetRenderTarget(renderer, camera.m_targetTexture);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0xFF);
SDL_RenderClear(renderer);
// Draw Sprite
shopSprite.DrawSprite(renderer, &camera, 0, 0);
characterSprite.DrawSprite(renderer, &camera, 116, 66);
// Screen target
SDL_SetRenderTarget(renderer, NULL);
SDL_SetRenderDrawColor(renderer, 0x00, 0xFF, 0x00, 0xFF);
SDL_RenderClear(renderer);
camera.Draw(renderer, Window_Height);
SDL_RenderPresent(renderer);
}
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
|
코드를 입력하고 빌드한다.
※ 참고
| [SDL] SDL Box2D Collision Contact Point & Normal Vector - Box2D 충돌 지점과 법선 벡터 (0) | 2024.01.31 |
|---|---|
| [SDL] SDL Box2D Add Collision Shape - Box2D 충돌 감지 (1) | 2024.01.30 |
| [SDL] SDL Box2D DebugDraw - 디버그 드로우 (1) | 2024.01.30 |
| [SDL] SDL Box2D Collision - Box2D 충돌 (1) | 2024.01.30 |
| [SDL] SDL Box2D - 물리 라이브러리 (0) | 2024.01.27 |
오브젝트가 충돌한 포인트를 확인해 보자.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
#include <iostream>
#include "SDL.h"
#include "box2d/box2d.h"
class DebugDrawer : public b2Draw
{
public:
DebugDrawer(SDL_Renderer* renderer) {
this->renderer = renderer;
}
private:
SDL_Renderer* renderer;
void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {}
void DrawPoint(const b2Vec2& p, float size, const b2Color& color) {}
void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {
SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
SDL_FRect* rect = new SDL_FRect{ vertices[0].x, vertices[0].y, vertices[1].x
- vertices[0].x, vertices[3].y - vertices[0].y };
SDL_RenderDrawRectF(renderer, rect);
}
void DrawCircle(const b2Vec2& center, float radius, const b2Color& color) {}
void DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color) {}
void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) {}
void DrawTransform(const b2Transform& xf) {}
};
int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* window = SDL_CreateWindow("SDL Test", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_RESIZABLE);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Surface* playerSurface = SDL_LoadBMP("player.bmp");
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, playerSurface);
// World 정의
b2Vec2 gravity(0.0f, 9.8f);
b2World world(gravity);
// DebugDraw 정의
DebugDrawer* debugDrawer = new DebugDrawer(renderer);
debugDrawer->SetFlags(b2Draw::e_shapeBit | b2Draw::e_jointBit |
b2Draw::e_centerOfMassBit | b2Draw::e_aabbBit | b2Draw::e_pairBit);
world.SetDebugDraw(debugDrawer);
// Player 정의
b2BodyDef playerBodyDef;
playerBodyDef.type = b2_dynamicBody;
playerBodyDef.position.Set(0.0f, 0.0f);
playerBodyDef.linearVelocity = b2Vec2(50.0f, 0.0f);
playerBodyDef.angularVelocity = 0.2f;
b2Body* playerBody = world.CreateBody(&playerBodyDef);
b2PolygonShape dynamicBox;
dynamicBox.SetAsBox((float)playerSurface->w / 2, (float)playerSurface->h / 2);
b2FixtureDef fixtureDef;
fixtureDef.shape = &dynamicBox;
fixtureDef.density = 1.0f;
fixtureDef.friction = 0.3f;
fixtureDef.restitution = 0.5f;
playerBody->CreateFixture(&fixtureDef);
// Ground 정의
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, 400.0f);
b2Body* groundBody = world.CreateBody(&groundBodyDef);
b2PolygonShape groundBox;
groundBox.SetAsBox(500.0f, 0.0f);
SDL_Rect groundRect = { 0, 400, 500, 10 };
groundBody->CreateFixture(&groundBox, 0.0f);
// Wall 정의
b2BodyDef wallBodyDef;
wallBodyDef.position.Set(300.0f, 0.0f);
b2Body* wallBody = world.CreateBody(&wallBodyDef);
b2PolygonShape wallBox;
wallBox.SetAsBox(0.0f, 480.0f);
SDL_Rect wallRect = { 300, 0, 10, 480 };
wallBody->CreateFixture(&wallBox, 0.0f);
float timeStep = 1.0f / 500.0f;
int velocityIterations = 6;
int positionIterations = 2;
SDL_Event event;
bool quit = false;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
printf("Key pressed: %s\n", SDL_GetKeyName(event.key.keysym.sym));
if (event.key.keysym.sym == SDLK_SPACE) {
playerBody->SetTransform(b2Vec2(0.0f, 0.0f), 0.0f);
playerBody->SetLinearVelocity(b2Vec2(50.0f, 0.0f));
playerBody->SetAngularVelocity(0.2f);
}
if (event.key.keysym.sym == SDLK_ESCAPE)
quit = true;
break;
default:
break;
}
}
world.Step(timeStep, velocityIterations, positionIterations);
SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
SDL_RenderClear(renderer);
// Ground 그리기
SDL_SetRenderDrawColor(renderer, 220, 140, 20, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &groundRect);
// Wall 그리기
SDL_SetRenderDrawColor(renderer, 64, 64, 64, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &wallRect);
// Player 그리기
b2Vec2 playerPosition = playerBody->GetPosition();
SDL_Rect destRect = { (int)playerPosition.x - playerSurface->w / 2,
(int)playerPosition.y - playerSurface->h / 2, playerSurface->w, playerSurface->h };
SDL_RendererFlip flip = SDL_FLIP_NONE;
float angle = playerBody->GetAngle() * (180 / (float)M_PI);
SDL_RenderCopyEx(renderer, texture, NULL, &destRect, angle, NULL, flip);
// DebugDraw 그리기
world.DebugDraw();
// 가장 마지막에 contact point 그리기
SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE);
for (b2Contact* contact = world.GetContactList(); contact; contact = contact->GetNext()) {
for (int i = 0; i < contact->GetManifold()->pointCount; i++)
{
b2Vec2 point = contact->GetFixtureA()->GetBody()->GetWorldPoint(
contact->GetManifold()->points[i].localPoint);
SDL_FRect rect = { point.x - 5, point.y - 5, 10, 10 };
SDL_RenderFillRectF(renderer, &rect);
}
}
// A very important point to note if you do this, is that the existence of a contact in these
// lists does not mean that the two fixtures of the contact are actually touching - it only means
// their AABBs are touching. If you want to know if the fixtures themselves are really touching
// you can use IsTouching() to check.
SDL_RenderPresent(renderer);
}
delete debugDrawer;
SDL_DestroyTexture(texture);
SDL_FreeSurface(playerSurface);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
|
코드를 입력하고 빌드한다.
이제 검은색으로 법선 벡터 그리는 코드를 추가하자.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
// 가장 마지막에 contact point & 법선 벡터 그리기
for (b2Contact* contact = world.GetContactList(); contact; contact = contact->GetNext()) {
for (int i = 0; i < contact->GetManifold()->pointCount; i++)
{
b2Vec2 point = contact->GetFixtureA()->GetBody()->GetWorldPoint(
contact->GetManifold()->points[i].localPoint);
SDL_FRect rect = { point.x - 5, point.y - 5, 10, 10 };
SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE);
SDL_RenderFillRectF(renderer, &rect);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
SDL_RenderDrawLineF(renderer, point.x, point.y,
point.x + contact->GetManifold()->localNormal.x * 20, point.y + contact->GetManifold()->localNormal.y * 20);
}
}
// A very important point to note if you do this, is that the existence of a contact in these
// lists does not mean that the two fixtures of the contact are actually touching - it only means
// their AABBs are touching. If you want to know if the fixtures themselves are really touching
// you can use IsTouching() to check.
|
코드를 수정하고 빌드한다.
속도(velocity) 벡터는 아래와 같은 코드로 표시할 수 있다.
|
1
2
3
4
|
SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
b2Vec2 position = playerBody->GetPosition();
SDL_RenderDrawLineF(renderer, position.x, position.y,
position.x + playerBody->GetLinearVelocity().x * 10, position.y + playerBody->GetLinearVelocity().y * 10);
|
※ 참고
| [SDL] SDL 2D Camera - 2D 카메라 (0) | 2024.02.01 |
|---|---|
| [SDL] SDL Box2D Add Collision Shape - Box2D 충돌 감지 (1) | 2024.01.30 |
| [SDL] SDL Box2D DebugDraw - 디버그 드로우 (1) | 2024.01.30 |
| [SDL] SDL Box2D Collision - Box2D 충돌 (1) | 2024.01.30 |
| [SDL] SDL Box2D - 물리 라이브러리 (0) | 2024.01.27 |
한 오브젝트에 여러개의 Shape을 추가해 충돌을 감지해 보자.
XXXShape이나 FixtureDef를 CreateFixture()에 전달하면 충돌 감지기가 추가된다.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
#include <iostream>
#include "SDL.h"
#include "box2d/box2d.h"
class DebugDrawer : public b2Draw
{
public:
DebugDrawer(SDL_Renderer* renderer) {
this->renderer = renderer;
}
private:
SDL_Renderer* renderer;
void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {}
void DrawPoint(const b2Vec2& p, float size, const b2Color& color) {}
void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {
SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
SDL_FRect* rect = new SDL_FRect{ vertices[0].x, vertices[0].y, vertices[1].x
- vertices[0].x, vertices[3].y - vertices[0].y };
SDL_RenderDrawRectF(renderer, rect);
}
void DrawCircle(const b2Vec2& center, float radius, const b2Color& color) {}
void DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color) {}
void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) {}
void DrawTransform(const b2Transform& xf) {}
};
int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* window = SDL_CreateWindow("SDL Test", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_RESIZABLE);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Surface* playerSurface = SDL_LoadBMP("player.bmp");
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, playerSurface);
// World 정의
b2Vec2 gravity(0.0f, 9.8f);
b2World world(gravity);
// DebugDraw 정의
DebugDrawer* debugDrawer = new DebugDrawer(renderer);
debugDrawer->SetFlags(b2Draw::e_shapeBit | b2Draw::e_jointBit |
b2Draw::e_centerOfMassBit | b2Draw::e_aabbBit | b2Draw::e_pairBit);
world.SetDebugDraw(debugDrawer);
// Player 정의
b2BodyDef playerBodyDef;
playerBodyDef.type = b2_dynamicBody;
playerBodyDef.position.Set(0.0f, 0.0f);
playerBodyDef.linearVelocity = b2Vec2(50.0f, 0.0f);
playerBodyDef.angularVelocity = 0.2f;
b2Body* playerBody = world.CreateBody(&playerBodyDef);
b2PolygonShape dynamicBox;
dynamicBox.SetAsBox((float)playerSurface->w / 2, (float)playerSurface->h / 2);
b2FixtureDef fixtureDef;
fixtureDef.shape = &dynamicBox;
fixtureDef.density = 1.0f;
fixtureDef.friction = 0.3f;
fixtureDef.restitution = 0.5f;
playerBody->CreateFixture(&fixtureDef);
// Player에 shape 추가
b2PolygonShape another;
another.SetAsBox(10, 40, b2Vec2(0, -60), 0.0f);
playerBody->CreateFixture(&another, 1.0f);
// Creates a fixture from a shape and attach it to this body. This is a convenience function.
// Use b2FixtureDef if you need to set parameters like friction, restitution, user data, or
// filtering. If the density is non-zero, this function automatically updates the mass of the body.
/*
b2Fixture* temp = NULL;
for (b2Fixture* fix = playerBody->GetFixtureList(); fix; fix=fix->GetNext()) {
std::cout << fix->GetFriction() << std::endl;
if (fix->GetFriction() == 0.2f)
temp = fix;
// 여기서 바로 playerBody->DestroyFixture()를 호출하면 fix가 파괴되어 GetNext()를 호출 할 수
// 없게 된다. 임시 변수에 저장하고 for문을 벗어나면 파괴하자.
}
if (temp != NULL)
playerBody->DestroyFixture(temp);
// 이 예제에서는 Friction값을 비교해서 삭제할 Fixture를 선택했지만 필요하다면
// UserData를 설정해서 비교하자.
*/
// Ground 정의
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, 400.0f);
b2Body* groundBody = world.CreateBody(&groundBodyDef);
b2PolygonShape groundBox;
groundBox.SetAsBox(500.0f, 0.0f);
SDL_Rect groundRect = { 0, 400, 500, 10 };
groundBody->CreateFixture(&groundBox, 0.0f);
// Wall 정의
b2BodyDef wallBodyDef;
wallBodyDef.position.Set(300.0f, 0.0f);
b2Body* wallBody = world.CreateBody(&wallBodyDef);
b2PolygonShape wallBox;
wallBox.SetAsBox(0.0f, 480.0f);
SDL_Rect wallRect = { 300, 0, 10, 480 };
wallBody->CreateFixture(&wallBox, 0.0f);
float timeStep = 1.0f / 500.0f;
int velocityIterations = 6;
int positionIterations = 2;
SDL_Event event;
bool quit = false;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
printf("Key pressed: %s\n", SDL_GetKeyName(event.key.keysym.sym));
if (event.key.keysym.sym == SDLK_SPACE) {
playerBody->SetTransform(b2Vec2(0.0f, 0.0f), 0.0f);
playerBody->SetLinearVelocity(b2Vec2(50.0f, 0.0f));
playerBody->SetAngularVelocity(0.2f);
}
if (event.key.keysym.sym == SDLK_ESCAPE)
quit = true;
break;
default:
break;
}
}
world.Step(timeStep, velocityIterations, positionIterations);
SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
SDL_RenderClear(renderer);
// Ground 그리기
SDL_SetRenderDrawColor(renderer, 220, 140, 20, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &groundRect);
// Wall 그리기
SDL_SetRenderDrawColor(renderer, 64, 64, 64, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &wallRect);
// Player 그리기
b2Vec2 playerPosition = playerBody->GetPosition();
SDL_Rect destRect = { (int)playerPosition.x - playerSurface->w / 2,
(int)playerPosition.y - playerSurface->h / 2, playerSurface->w, playerSurface->h };
SDL_RendererFlip flip = SDL_FLIP_NONE;
float angle = playerBody->GetAngle() * (180 / (float)M_PI);
SDL_RenderCopyEx(renderer, texture, NULL, &destRect, angle, NULL, flip);
// 가장 마지막에 DebugDraw 그리기
world.DebugDraw();
SDL_RenderPresent(renderer);
}
delete debugDrawer;
SDL_DestroyTexture(texture);
SDL_FreeSurface(playerSurface);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
|
코드를 입력하고 빌드한다.
| [SDL] SDL 2D Camera - 2D 카메라 (0) | 2024.02.01 |
|---|---|
| [SDL] SDL Box2D Collision Contact Point & Normal Vector - Box2D 충돌 지점과 법선 벡터 (0) | 2024.01.31 |
| [SDL] SDL Box2D DebugDraw - 디버그 드로우 (1) | 2024.01.30 |
| [SDL] SDL Box2D Collision - Box2D 충돌 (1) | 2024.01.30 |
| [SDL] SDL Box2D - 물리 라이브러리 (0) | 2024.01.27 |
Box2D DebugDraw를 사용해 보자.
b2Draw 클래스를 상속해 DebugDraw 클래스를 만들고 사용하면 된다.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include <iostream>
#include "SDL.h"
#include "box2d/box2d.h"
class DebugDrawer : public b2Draw
{
public:
DebugDrawer(SDL_Renderer* renderer) {
this->renderer = renderer;
}
private:
SDL_Renderer* renderer;
void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {}
void DrawPoint(const b2Vec2& p, float size, const b2Color& color) {}
void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {
SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
SDL_FRect* rect = new SDL_FRect{ vertices[0].x, vertices[0].y, vertices[1].x
- vertices[0].x, vertices[3].y - vertices[0].y };
SDL_RenderDrawRectF(renderer, rect);
}
void DrawCircle(const b2Vec2& center, float radius, const b2Color& color) {}
void DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color) {}
void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) {}
void DrawTransform(const b2Transform& xf) {}
};
int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* window = SDL_CreateWindow("SDL Test", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_RESIZABLE);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Surface* playerSurface = SDL_LoadBMP("player.bmp");
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, playerSurface);
// World 정의
b2Vec2 gravity(0.0f, 9.8f);
b2World world(gravity);
// DebugDraw 정의
DebugDrawer* debugDrawer = new DebugDrawer(renderer);
debugDrawer->SetFlags(b2Draw::e_shapeBit | b2Draw::e_jointBit |
b2Draw::e_centerOfMassBit | b2Draw::e_aabbBit | b2Draw::e_pairBit);
world.SetDebugDraw(debugDrawer);
// Player 정의
b2BodyDef playerBodyDef;
playerBodyDef.type = b2_dynamicBody;
playerBodyDef.position.Set(0.0f, 0.0f);
playerBodyDef.linearVelocity = b2Vec2(50.0f, 0.0f);
playerBodyDef.angularVelocity = 0.2f;
b2Body* playerBody = world.CreateBody(&playerBodyDef);
b2PolygonShape dynamicBox;
dynamicBox.SetAsBox((float)playerSurface->w / 2, (float)playerSurface->h / 2);
b2FixtureDef fixtureDef;
fixtureDef.shape = &dynamicBox;
fixtureDef.density = 1.0f;
fixtureDef.friction = 0.3f;
fixtureDef.restitution = 0.5f;
playerBody->CreateFixture(&fixtureDef);
// Ground 정의
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, 400.0f);
b2Body* groundBody = world.CreateBody(&groundBodyDef);
b2PolygonShape groundBox;
groundBox.SetAsBox(500.0f, 0.0f);
SDL_Rect groundRect = { 0, 400, 500, 10 };
groundBody->CreateFixture(&groundBox, 0.0f);
// Wall 정의
b2BodyDef wallBodyDef;
wallBodyDef.position.Set(300.0f, 0.0f);
b2Body* wallBody = world.CreateBody(&wallBodyDef);
b2PolygonShape wallBox;
wallBox.SetAsBox(0.0f, 480.0f);
SDL_Rect wallRect = { 300, 0, 10, 480 };
wallBody->CreateFixture(&wallBox, 0.0f);
float timeStep = 1.0f / 500.0f;
int velocityIterations = 6;
int positionIterations = 2;
SDL_Event event;
bool quit = false;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
printf("Key pressed: %s\n", SDL_GetKeyName(event.key.keysym.sym));
if (event.key.keysym.sym == SDLK_SPACE) {
playerBody->SetTransform(b2Vec2(0.0f, 0.0f), 0.0f);
playerBody->SetLinearVelocity(b2Vec2(50.0f, 0.0f));
playerBody->SetAngularVelocity(0.2f);
}
if (event.key.keysym.sym == SDLK_ESCAPE)
quit = true;
break;
default:
break;
}
}
world.Step(timeStep, velocityIterations, positionIterations);
SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
SDL_RenderClear(renderer);
// Ground 그리기
SDL_SetRenderDrawColor(renderer, 220, 140, 20, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &groundRect);
// Wall 그리기
SDL_SetRenderDrawColor(renderer, 64, 64, 64, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &wallRect);
// Player 그리기
b2Vec2 playerPosition = playerBody->GetPosition();
SDL_Rect destRect = { (int)playerPosition.x - playerSurface->w / 2,
(int)playerPosition.y - playerSurface->h / 2, playerSurface->w, playerSurface->h };
SDL_RendererFlip flip = SDL_FLIP_NONE;
float angle = playerBody->GetAngle() * (180 / (float)M_PI);
SDL_RenderCopyEx(renderer, texture, NULL, &destRect, angle, NULL, flip);
// 가장 마지막에 DebugDraw 그리기
world.DebugDraw();
SDL_RenderPresent(renderer);
}
// debugDrawer 해제
delete debugDrawer;
SDL_DestroyTexture(texture);
SDL_FreeSurface(playerSurface);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
|
코드를 입력하고 빌드한다.
※ 참고
| [SDL] SDL Box2D Collision Contact Point & Normal Vector - Box2D 충돌 지점과 법선 벡터 (0) | 2024.01.31 |
|---|---|
| [SDL] SDL Box2D Add Collision Shape - Box2D 충돌 감지 (1) | 2024.01.30 |
| [SDL] SDL Box2D Collision - Box2D 충돌 (1) | 2024.01.30 |
| [SDL] SDL Box2D - 물리 라이브러리 (0) | 2024.01.27 |
| [SDL] SDL OpenCV (1) | 2024.01.27 |
충돌을 감지하고 어떤 오브젝트가 충돌했는지 확인해 보자.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
#include <iostream>
#include "SDL.h"
#include "box2d/box2d.h"
int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* window = SDL_CreateWindow("SDL Test", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_RESIZABLE);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Surface* playerSurface = SDL_LoadBMP("player.bmp");
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, playerSurface);
// World 정의
b2Vec2 gravity(0.0f, 9.8f);
b2World world(gravity);
// Player 정의
b2BodyDef playerBodyDef;
playerBodyDef.type = b2_dynamicBody;
playerBodyDef.position.Set(0.0f, 0.0f);
playerBodyDef.linearVelocity = b2Vec2(50.0f, 0.0f);
playerBodyDef.angularVelocity = 0.2f;
b2Body* playerBody = world.CreateBody(&playerBodyDef);
b2PolygonShape dynamicBox;
dynamicBox.SetAsBox((float)playerSurface->w / 2, (float)playerSurface->h / 2);
b2FixtureDef fixtureDef;
fixtureDef.shape = &dynamicBox;
fixtureDef.density = 1.0f;
fixtureDef.friction = 0.3f;
fixtureDef.restitution = 0.5f;
playerBody->CreateFixture(&fixtureDef);
// Player 유저 정보
const char* playerName = "Player";
playerBody->GetUserData().pointer = reinterpret_cast<uintptr_t>(playerName);
// Ground 정의
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, 400.0f);
b2Body* groundBody = world.CreateBody(&groundBodyDef);
b2PolygonShape groundBox;
groundBox.SetAsBox(500.0f, 0.0f);
SDL_Rect groundRect = { 0, 400, 500, 10 };
groundBody->CreateFixture(&groundBox, 0.0f);
// Ground 유저 정보
const char* groundName = "Ground";
groundBody->GetUserData().pointer = reinterpret_cast<uintptr_t>(groundName);
// Wall 정의
b2BodyDef wallBodyDef;
wallBodyDef.position.Set(300.0f, 0.0f);
b2Body* wallBody = world.CreateBody(&wallBodyDef);
b2PolygonShape wallBox;
wallBox.SetAsBox(0.0f, 480.0f);
SDL_Rect wallRect = { 300, 0, 10, 480 };
wallBody->CreateFixture(&wallBox, 0.0f);
// Wall 유저 정보
const char* wallName = "Wall";
wallBody->GetUserData().pointer = reinterpret_cast<uintptr_t>(wallName);
float timeStep = 1.0f / 500.0f;
int velocityIterations = 6;
int positionIterations = 2;
SDL_Event event;
bool quit = false;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
printf("Key pressed: %s\n", SDL_GetKeyName(event.key.keysym.sym));
if (event.key.keysym.sym == SDLK_SPACE) {
playerBody->SetTransform(b2Vec2(0.0f, 0.0f), 0.0f);
playerBody->SetLinearVelocity(b2Vec2(50.0f, 0.0f));
playerBody->SetAngularVelocity(0.2f);
}
if (event.key.keysym.sym == SDLK_ESCAPE)
quit = true;
break;
default:
break;
}
}
world.Step(timeStep, velocityIterations, positionIterations);
for (b2Contact* c = world.GetContactList(); c; c = c->GetNext())
{
if (c->IsTouching()) {
printf("FixtureA: %s\n", (char*)(c->GetFixtureA()->GetBody()->GetUserData().pointer));
printf("FixtureB: %s\n", (char*)(c->GetFixtureB()->GetBody()->GetUserData().pointer));
printf("Count: %d\n", c->GetManifold()->pointCount);
}
//if (c->GetFixtureA()->IsSensor() == false)
//c->GetFixtureA()->SetSensor(true);
}
// A very important point to note if you do this, is that the existence of a contact in these
// lists does not mean that the two fixtures of the contact are actually touching - it only
// means their AABBs are touching. If you want to know if the fixtures themselves are really
// touching you can use c->IsTouching() to check.
SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
SDL_RenderClear(renderer);
// Ground 그리기
SDL_SetRenderDrawColor(renderer, 220, 140, 20, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &groundRect);
// Wall 그리기
SDL_SetRenderDrawColor(renderer, 64, 64, 64, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &wallRect);
// Player 그리기
b2Vec2 playerPosition = playerBody->GetPosition();
SDL_Rect destRect = { (int)playerPosition.x - playerSurface->w / 2,
(int)playerPosition.y - playerSurface->h / 2, playerSurface->w, playerSurface->h };
SDL_RendererFlip flip = SDL_FLIP_NONE;
float angle = playerBody->GetAngle() * (180 / (float)M_PI);
SDL_RenderCopyEx(renderer, texture, NULL, &destRect, angle, NULL, flip);
SDL_RenderPresent(renderer);
}
SDL_DestroyTexture(texture);
SDL_FreeSurface(playerSurface);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
|
코드를 작성하고 빌드한다.
오브젝트 UserData 설정시 SetUserData()를 사용하면 안된다는 것에 주의한다. (아래 참고 참조)
※ 참고
Box2D Dynamic Module - Contacts
| [SDL] SDL Box2D Add Collision Shape - Box2D 충돌 감지 (1) | 2024.01.30 |
|---|---|
| [SDL] SDL Box2D DebugDraw - 디버그 드로우 (1) | 2024.01.30 |
| [SDL] SDL Box2D - 물리 라이브러리 (0) | 2024.01.27 |
| [SDL] SDL OpenCV (1) | 2024.01.27 |
| [SDL] SDL Dear ImGui Project - SDL Dear ImGui SDL 프로젝트 (1) | 2024.01.26 |
