Debian Codegraph @

Sources/Jazz2/Actors/Solid/SpikeBall.cpp

raw
1 #include "SpikeBall.h"
2 #include "../../ContentResolver.h"
3 #include "../../ILevelHandler.h"
4 #include "../../Tiles/TileMap.h"
5
6 #include "../../../nCine/Graphics/RenderQueue.h"
7
8 namespace Jazz2::Actors::Solid
9 {
10 SpikeBall::SpikeBall()
11 {
12 }
13
14 void SpikeBall::Preload(const ActorActivationDetails& details)
15 {
16 PreloadMetadataAsync("MovingPlatform/SpikeBall"_s);
17 }
18
19 Task<bool> SpikeBall::OnActivatedAsync(const ActorActivationDetails& details)
20 {
21 std::uint8_t length = details.Params[2];
22 _speed = *(std::int8_t*)&details.Params[1] * 0.0072f;
23 std::uint8_t sync = details.Params[0];
24 _isSwing = details.Params[3] != 0;
25 _phase = sync * fPiOver2 - _speed * _levelHandler->GetElapsedFrames();
26 _shade = details.Params[4] != 0;
27
28 _originPos = _pos;
29 _originLayer = _renderer.layer() - 12;
30
31 SetState(ActorState::IsInvulnerable, true);
32 SetState(ActorState::CanBeFrozen | ActorState::CollideWithTileset | ActorState::ApplyGravitation, false);
33
34 async_await RequestMetadataAsync("MovingPlatform/SpikeBall"_s);
35 SetAnimation((AnimState)0);
36
37 auto& resolver = ContentResolver::Get();
38 for (std::int32_t i = 0; i < length; i++) {
39 ChainPiece& piece = _pieces.emplace_back();
40 if (!resolver.IsHeadless()) {
41 piece.Command = std::make_unique<RenderCommand>(RenderCommand::Type::Sprite);
42 piece.Command->GetMaterial().SetShaderProgramType(Material::ShaderProgramType::Sprite);
43 piece.Command->GetMaterial().SetBlendingEnabled(true);
44 piece.Command->GetMaterial().ReserveUniformsDataMemory();
45 piece.Command->GetGeometry().SetDrawParameters(GL_TRIANGLE_STRIP, 0, 4);
46
47 auto* textureUniform = piece.Command->GetMaterial().Uniform(Material::TextureUniformName);
48 if (textureUniform && textureUniform->GetIntValue(0) != 0) {
49 textureUniform->SetIntValue(0); // GL_TEXTURE0
50 }
51 }
52 }
53
54 async_return true;
55 }
56
57 void SpikeBall::OnUpdate(float timeMult)
58 {
59 _phase -= _speed * timeMult;
60 if (_speed > 0.0f) {
61 if (_phase < -fTwoPi) {
62 _phase += fTwoPi;
63 }
64 } else if (_speed < 0.0f) {
65 if (_phase > fTwoPi) {
66 _phase -= fTwoPi;
67 }
68 }
69
70 float scale = 1.0f;
71 MoveInstantly(GetPhasePosition((std::int32_t)_pieces.size(), &scale), MoveType::Absolute | MoveType::Force);
72
73 for (std::int32_t i = 0; i < _pieces.size(); i++) {
74 _pieces[i].Pos = GetPhasePosition(i, &_pieces[i].Scale);
75 }
76
77 _canHurtPlayer = (std::abs(1.0f - scale) < 0.06f);
78
79 _renderer.setScale(scale);
80 _renderer.setLayer(_originLayer + (std::uint16_t)(scale * 20));
81 if (_shade) {
82 _renderer.setColor(scale < 1.0f ? Colorf(scale, scale, scale, 1.0f) : Colorf::White);
83 }
84 }
85
86 void SpikeBall::OnUpdateHitbox()
87 {
88 EnemyBase::OnUpdateHitbox();
89
90 AABBInner.L += 8.0f;
91 AABBInner.T += 8.0f;
92 AABBInner.R -= 8.0f;
93 AABBInner.B -= 8.0f;
94 }
95
96 bool SpikeBall::OnDraw(RenderQueue& renderQueue)
97 {
98 if (!_pieces.empty()) {
99 auto* chainAnim = _metadata->FindAnimation((AnimState)1);
100 if (chainAnim != nullptr && chainAnim->Base->TextureDiffuse != nullptr) {
101 Vector2i texSize = chainAnim->Base->TextureDiffuse->GetSize();
102
103 for (std::int32_t i = 0; i < _pieces.size(); i++) {
104 auto command = _pieces[i].Command.get();
105 float scale = _pieces[i].Scale;
106
107 std::int32_t curAnimFrame = chainAnim->FrameOffset + (i % chainAnim->FrameCount);
108 std::int32_t col = curAnimFrame % chainAnim->Base->FrameConfiguration.X;
109 std::int32_t row = curAnimFrame / chainAnim->Base->FrameConfiguration.X;
110 float texScaleX = (float(chainAnim->Base->FrameDimensions.X) / float(texSize.X));
111 float texBiasX = (float(chainAnim->Base->FrameDimensions.X * col) / float(texSize.X));
112 float texScaleY = (float(chainAnim->Base->FrameDimensions.Y) / float(texSize.Y));
113 float texBiasY = (float(chainAnim->Base->FrameDimensions.Y * row) / float(texSize.Y));
114
115 auto instanceBlock = command->GetMaterial().UniformBlock(Material::InstanceBlockName);
116 instanceBlock->GetUniform(Material::TexRectUniformName)->SetFloatValue(texScaleX, texBiasX, texScaleY, texBiasY);
117 instanceBlock->GetUniform(Material::SpriteSizeUniformName)->SetFloatValue((float)chainAnim->Base->FrameDimensions.X, (float)chainAnim->Base->FrameDimensions.Y);
118 if (_shade) {
119 instanceBlock->GetUniform(Material::ColorUniformName)->SetFloatVector((scale < 1.0f ? Colorf(scale, scale, scale, 1.0f) : Colorf::White).Data());
120 } else {
121 instanceBlock->GetUniform(Material::ColorUniformName)->SetFloatVector(Colorf::White.Data());
122 }
123
124 auto& pos = _pieces[i].Pos;
125 command->SetTransformation(Matrix4x4f::Translation(pos.X - chainAnim->Base->FrameDimensions.X / 2, pos.Y - chainAnim->Base->FrameDimensions.Y / 2, 0.0f));
126 command->SetLayer(_originLayer + (uint16_t)(scale * 20));
127 command->GetMaterial().SetTexture(*chainAnim->Base->TextureDiffuse.get());
128
129 renderQueue.AddCommand(command);
130 }
131 }
132 }
133
134 return EnemyBase::OnDraw(renderQueue);
135 }
136
137 Vector2f SpikeBall::GetPhasePosition(std::int32_t distance, float* scale)
138 {
139 float effectivePhase = _phase;
140
141 if (_isSwing) {
142 effectivePhase = fPiOver2 + sinf(effectivePhase) * fPiOver2;
143 } else if (_pieces.size() > 4 && distance > 0 && distance < _pieces.size()) {
144 float shift = sinf(fPi * (float)(distance + 1) / _pieces.size()) * _speed * 4.0f;
145 effectivePhase -= shift;
146 }
147
148 float multiX = cosf(effectivePhase);
149 float multiY = sinf(effectivePhase);
150
151 if (scale != nullptr) {
152 *scale = 1.0f + multiX * 0.4f * distance / _pieces.size();
153 }
154 return Vector2f(
155 std::round(_originPos.X),
156 std::round(_originPos.Y + multiY * distance * 12.0f)
157 );
158 }
159 }