author | unc0rr |
Sun, 07 Nov 2010 19:27:22 +0300 | |
changeset 4171 | 7bbd7ab84454 |
parent 3971 | 5c82ee165ed5 |
child 4004 | b1c2c2f6fc5e |
child 4222 | e0de341a75ab |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
883 | 3 |
* Copyright (c) 2004-2008 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 4 |
* |
183 | 5 |
* This program is free software; you can redistribute it and/or modify |
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
4 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
4 | 17 |
*) |
18 |
||
2623 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
4 | 21 |
unit uStore; |
22 |
interface |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
23 |
uses sysutils, uConsts, uTeams, SDLh, GLunit, uWorld; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
24 |
|
4 | 25 |
|
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
26 |
var PixelFormat: PSDL_PixelFormat; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
27 |
SDLPrimSurface: PSDL_Surface; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
28 |
PauseTexture, |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
29 |
SyncTexture, |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
30 |
ConfirmTexture: PTexture; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
31 |
cScaleFactor: GLfloat; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
32 |
SupportNPOTT: Boolean; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
33 |
Step: LongInt; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
34 |
squaresize : LongInt; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
35 |
numsquares : LongInt; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
36 |
ProgrTex: PTexture; |
2801 | 37 |
MissionIcons: PSDL_Surface; |
2811 | 38 |
ropeIconTex: PTexture; |
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
39 |
rotationQt: GLfloat; |
3697 | 40 |
|
3038 | 41 |
procedure initModule; |
42 |
procedure freeModule; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
43 |
|
4 | 44 |
procedure StoreLoad; |
45 |
procedure StoreRelease; |
|
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
46 |
procedure DrawSpriteFromRect(Sprite: TSprite; r: TSDL_Rect; X, Y, Height, Position: LongInt); |
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
47 |
procedure DrawSprite (Sprite: TSprite; X, Y, Frame: LongInt); |
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
48 |
procedure DrawSprite2(Sprite: TSprite; X, Y, FrameX, FrameY: LongInt); |
1939 | 49 |
procedure DrawSpriteClipped(Sprite: TSprite; X, Y, TopY, RightX, BottomY, LeftX: LongInt); |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3491
diff
changeset
|
50 |
procedure DrawTexture(X, Y: LongInt; Texture: PTexture; Scale: GLfloat = 1.0); |
2811 | 51 |
procedure DrawTextureF(Texture: PTexture; Scale: GLfloat; X, Y, Frame, Dir, w, h: LongInt); |
52 |
procedure DrawRotatedTextureF(Texture: PTexture; Scale, OffsetX, OffsetY: GLfloat; X, Y, Frame, Dir, w, h: LongInt; Angle: real); |
|
822 | 53 |
procedure DrawRotated(Sprite: TSprite; X, Y, Dir: LongInt; Angle: real); |
853 | 54 |
procedure DrawRotatedF(Sprite: TSprite; X, Y, Frame, Dir: LongInt; Angle: real); |
822 | 55 |
procedure DrawRotatedTex(Tex: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real); |
762 | 56 |
procedure DrawCentered(X, Top: LongInt; Source: PTexture); |
2958 | 57 |
procedure DrawFromRect(X, Y, W, H: LongInt; r: PSDL_Rect; SourceTexture: PTexture); |
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
58 |
procedure DrawFromRect(X, Y: LongInt; r: PSDL_Rect; SourceTexture: PTexture); |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1854
diff
changeset
|
59 |
procedure DrawHedgehog(X, Y: LongInt; Dir: LongInt; Pos, Step: LongWord; Angle: real); |
1431 | 60 |
procedure DrawFillRect(r: TSDL_Rect); |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
61 |
procedure DrawCircle(X, Y, Radius: LongInt; Width: Single; r, g, b, a: Byte); |
2801 | 62 |
procedure DrawRoundRect(rect: PSDL_Rect; BorderColor, FillColor: Longword; Surface: PSDL_Surface; Clear: boolean); |
2905 | 63 |
function CheckCJKFont(s: ansistring; font: THWFont): THWFont; |
64 |
function RenderStringTex(s: ansistring; Color: Longword; font: THWFont): PTexture; |
|
65 |
function RenderSpeechBubbleTex(s: ansistring; SpeechType: Longword; font: THWFont): PTexture; |
|
2017 | 66 |
procedure flipSurface(Surface: PSDL_Surface; Vertical: Boolean); |
67 |
//procedure rotateSurface(Surface: PSDL_Surface); |
|
68 |
procedure copyRotatedSurface(src, dest: PSDL_Surface); // this is necessary since width/height are read only in SDL |
|
3169
c8c6ac44f51b
prophylactic removal of some Integer references, raise a few of the template islands up a bit so they work inverted without triggering border
nemo
parents:
3165
diff
changeset
|
69 |
procedure copyToXY(src, dest: PSDL_Surface; destX, destY: LongInt); |
4 | 70 |
procedure RenderHealth(var Hedgehog: THedgehog); |
71 |
procedure AddProgress; |
|
510 | 72 |
procedure FinishProgress; |
2905 | 73 |
function LoadImage(const filename: shortstring; imageFlags: LongInt): PSDL_Surface; |
753 | 74 |
procedure SetupOpenGL; |
2161
0c8634241fa4
Some work on zooming. Hedgewars are now unplayable.
unc0rr
parents:
2154
diff
changeset
|
75 |
procedure SetScale(f: GLfloat); |
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
76 |
function RenderHelpWindow(caption, subcaption, description, extra: ansistring; extracolor: LongInt; iconsurf: PSDL_Surface; iconrect: PSDL_Rect): PTexture; |
2747 | 77 |
procedure RenderWeaponTooltip(atype: TAmmoType); |
78 |
procedure ShowWeaponTooltip(x, y: LongInt); |
|
79 |
procedure FreeWeaponTooltip; |
|
3376 | 80 |
procedure Tint(r, g, b, a: Byte); inline; |
3445 | 81 |
procedure Tint(c: Longword); inline; |
4 | 82 |
|
83 |
implementation |
|
3928
2560731c860d
move all mobile-related functions in their own module, provides a structure for future mobile ports
koda
parents:
3922
diff
changeset
|
84 |
uses uMisc, uConsole, uLocale, uMobile; |
4 | 85 |
|
2735 | 86 |
type TGPUVendor = (gvUnknown, gvNVIDIA, gvATI, gvIntel, gvApple); |
2568
e654cbfb23ba
Bunch of neat stuff by Smaxx. ATI check, translucent name tags to reduce terrain fail, disabling health crates on invulnerable hogs. Also tweaks to prior stuff.
nemo
parents:
2567
diff
changeset
|
87 |
|
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
88 |
var HHTexture: PTexture; |
3169
c8c6ac44f51b
prophylactic removal of some Integer references, raise a few of the template islands up a bit so they work inverted without triggering border
nemo
parents:
3165
diff
changeset
|
89 |
MaxTextureSize: LongInt; |
2735 | 90 |
cGPUVendor: TGPUVendor; |
3376 | 91 |
lastTint: Longword; |
4 | 92 |
|
3376 | 93 |
procedure Tint(r, g, b, a: Byte); inline; |
94 |
var nc: Longword; |
|
95 |
begin |
|
96 |
nc:= (a shl 24) or (b shl 16) or (g shl 8) or r; |
|
97 |
if nc = lastTint then |
|
98 |
exit; |
|
99 |
glColor4ub(r, g, b, a); |
|
100 |
lastTint:= nc; |
|
101 |
end; |
|
102 |
||
3445 | 103 |
procedure Tint(c: Longword); inline; |
104 |
begin |
|
105 |
Tint(((c shr 16) and $FF), ((c shr 8) and $FF), (c and $FF), $FF); |
|
106 |
end; |
|
107 |
||
351 | 108 |
procedure DrawRoundRect(rect: PSDL_Rect; BorderColor, FillColor: Longword; Surface: PSDL_Surface; Clear: boolean); |
47 | 109 |
var r: TSDL_Rect; |
110 |
begin |
|
111 |
r:= rect^; |
|
83 | 112 |
if Clear then SDL_FillRect(Surface, @r, 0); |
764
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
113 |
|
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
114 |
BorderColor:= SDL_MapRGB(Surface^.format, BorderColor shr 16, BorderColor shr 8, BorderColor and $FF); |
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
115 |
FillColor:= SDL_MapRGB(Surface^.format, FillColor shr 16, FillColor shr 8, FillColor and $FF); |
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
116 |
|
351 | 117 |
r.y:= rect^.y + 1; |
118 |
r.h:= rect^.h - 2; |
|
47 | 119 |
SDL_FillRect(Surface, @r, BorderColor); |
351 | 120 |
r.x:= rect^.x + 1; |
121 |
r.w:= rect^.w - 2; |
|
122 |
r.y:= rect^.y; |
|
123 |
r.h:= rect^.h; |
|
47 | 124 |
SDL_FillRect(Surface, @r, BorderColor); |
351 | 125 |
r.x:= rect^.x + 2; |
126 |
r.y:= rect^.y + 1; |
|
127 |
r.w:= rect^.w - 4; |
|
128 |
r.h:= rect^.h - 2; |
|
47 | 129 |
SDL_FillRect(Surface, @r, FillColor); |
351 | 130 |
r.x:= rect^.x + 1; |
131 |
r.y:= rect^.y + 2; |
|
132 |
r.w:= rect^.w - 2; |
|
133 |
r.h:= rect^.h - 4; |
|
47 | 134 |
SDL_FillRect(Surface, @r, FillColor) |
135 |
end; |
|
136 |
||
2905 | 137 |
function WriteInRoundRect(Surface: PSDL_Surface; X, Y: LongInt; Color: LongWord; Font: THWFont; s: ansistring): TSDL_Rect; |
351 | 138 |
var w, h: LongInt; |
4 | 139 |
tmpsurf: PSDL_Surface; |
140 |
clr: TSDL_Color; |
|
2695 | 141 |
finalRect: TSDL_Rect; |
4 | 142 |
begin |
3407 | 143 |
w:= 0; h:= 0; // avoid compiler hints |
2620
796269129c47
koda, can we try to keep unC0Rr's code formatting, and not just change it when we feel like it?
nemo
parents:
2619
diff
changeset
|
144 |
TTF_SizeUTF8(Fontz[Font].Handle, Str2PChar(s), w, h); |
2695 | 145 |
finalRect.x:= X; |
146 |
finalRect.y:= Y; |
|
147 |
finalRect.w:= w + FontBorder * 2 + 4; |
|
148 |
finalRect.h:= h + FontBorder * 2; |
|
149 |
DrawRoundRect(@finalRect, cWhiteColor, endian(cNearBlackColorChannels.value), Surface, true); |
|
2670 | 150 |
clr.r:= (Color shr 16) and $FF; |
2620
796269129c47
koda, can we try to keep unC0Rr's code formatting, and not just change it when we feel like it?
nemo
parents:
2619
diff
changeset
|
151 |
clr.g:= (Color shr 8) and $FF; |
796269129c47
koda, can we try to keep unC0Rr's code formatting, and not just change it when we feel like it?
nemo
parents:
2619
diff
changeset
|
152 |
clr.b:= Color and $FF; |
2665
50b4e544c163
complete transition of longword->sdl_color for TTF bindings
koda
parents:
2663
diff
changeset
|
153 |
tmpsurf:= TTF_RenderUTF8_Blended(Fontz[Font].Handle, Str2PChar(s), clr); |
2695 | 154 |
finalRect.x:= X + FontBorder + 2; |
155 |
finalRect.y:= Y + FontBorder; |
|
2620
796269129c47
koda, can we try to keep unC0Rr's code formatting, and not just change it when we feel like it?
nemo
parents:
2619
diff
changeset
|
156 |
SDLTry(tmpsurf <> nil, true); |
2695 | 157 |
SDL_UpperBlit(tmpsurf, nil, Surface, @finalRect); |
2620
796269129c47
koda, can we try to keep unC0Rr's code formatting, and not just change it when we feel like it?
nemo
parents:
2619
diff
changeset
|
158 |
SDL_FreeSurface(tmpsurf); |
2695 | 159 |
finalRect.x:= X; |
160 |
finalRect.y:= Y; |
|
161 |
finalRect.w:= w + FontBorder * 2 + 4; |
|
162 |
finalRect.h:= h + FontBorder * 2; |
|
163 |
WriteInRoundRect:= finalRect; |
|
4 | 164 |
end; |
165 |
||
2905 | 166 |
function WriteInRect(Surface: PSDL_Surface; X, Y: LongInt; Color: LongWord; Font: THWFont; s: ansistring): TSDL_Rect; |
2747 | 167 |
var w, h: LongInt; |
168 |
tmpsurf: PSDL_Surface; |
|
169 |
clr: TSDL_Color; |
|
170 |
finalRect: TSDL_Rect; |
|
171 |
begin |
|
3407 | 172 |
w:= 0; h:= 0; // avoid compiler hints |
2747 | 173 |
TTF_SizeUTF8(Fontz[Font].Handle, Str2PChar(s), w, h); |
174 |
finalRect.x:= X + FontBorder + 2; |
|
175 |
finalRect.y:= Y + FontBorder; |
|
176 |
finalRect.w:= w + FontBorder * 2 + 4; |
|
177 |
finalRect.h:= h + FontBorder * 2; |
|
178 |
clr.r:= Color shr 16; |
|
179 |
clr.g:= (Color shr 8) and $FF; |
|
180 |
clr.b:= Color and $FF; |
|
181 |
tmpsurf:= TTF_RenderUTF8_Blended(Fontz[Font].Handle, Str2PChar(s), clr); |
|
182 |
tmpsurf:= doSurfaceConversion(tmpsurf); |
|
183 |
SDLTry(tmpsurf <> nil, true); |
|
184 |
SDL_UpperBlit(tmpsurf, nil, Surface, @finalRect); |
|
185 |
SDL_FreeSurface(tmpsurf); |
|
186 |
finalRect.x:= X; |
|
187 |
finalRect.y:= Y; |
|
188 |
finalRect.w:= w + FontBorder * 2 + 4; |
|
189 |
finalRect.h:= h + FontBorder * 2; |
|
190 |
WriteInRect:= finalRect |
|
191 |
end; |
|
192 |
||
4 | 193 |
procedure StoreLoad; |
2905 | 194 |
var s: shortstring; |
4 | 195 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
196 |
procedure WriteNames(Font: THWFont); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
197 |
var t: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
198 |
i: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
199 |
r, rr: TSDL_Rect; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
200 |
drY: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
201 |
texsurf, flagsurf, iconsurf: PSDL_Surface; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
202 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
203 |
r.x:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
204 |
r.y:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
205 |
drY:= - 4; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
206 |
for t:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
207 |
with TeamsArray[t]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
208 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
209 |
NameTagTex:= RenderStringTex(TeamName, Clan^.Color, Font); |
690 | 210 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
211 |
r.w:= cTeamHealthWidth + 5; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
212 |
r.h:= NameTagTex^.h; |
690 | 213 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
214 |
texsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, r.w, r.h, 32, RMask, GMask, BMask, AMask); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
215 |
TryDo(texsurf <> nil, errmsgCreateSurface, true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
216 |
TryDo(SDL_SetColorKey(texsurf, SDL_SRCCOLORKEY, 0) = 0, errmsgTransparentSet, true); |
690 | 217 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
218 |
DrawRoundRect(@r, cWhiteColor, cNearBlackColorChannels.value, texsurf, true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
219 |
rr:= r; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
220 |
inc(rr.x, 2); dec(rr.w, 4); inc(rr.y, 2); dec(rr.h, 4); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
221 |
DrawRoundRect(@rr, Clan^.Color, Clan^.Color, texsurf, false); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
222 |
HealthTex:= Surface2Tex(texsurf, false); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
223 |
SDL_FreeSurface(texsurf); |
690 | 224 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
225 |
r.x:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
226 |
r.y:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
227 |
r.w:= 32; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
228 |
r.h:= 32; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
229 |
texsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, r.w, r.h, 32, RMask, GMask, BMask, AMask); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
230 |
TryDo(texsurf <> nil, errmsgCreateSurface, true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
231 |
TryDo(SDL_SetColorKey(texsurf, SDL_SRCCOLORKEY, 0) = 0, errmsgTransparentSet, true); |
2747 | 232 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
233 |
r.w:= 26; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
234 |
r.h:= 19; |
2747 | 235 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
236 |
DrawRoundRect(@r, cWhiteColor, cNearBlackColor, texsurf, true); |
3697 | 237 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
238 |
// overwrite flag for cpu teams and keep players from using it |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
239 |
if (Hedgehogs[0].Gear <> nil) and (Hedgehogs[0].BotLevel > 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
240 |
Flag:= 'cpu' |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
241 |
else if Flag = 'cpu' then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
242 |
Flag:= 'hedgewars'; |
3697 | 243 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
244 |
flagsurf:= LoadImage(Pathz[ptFlags] + '/' + Flag, ifNone); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
245 |
if flagsurf = nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
246 |
flagsurf:= LoadImage(Pathz[ptFlags] + '/hedgewars', ifNone); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
247 |
TryDo(flagsurf <> nil, 'Failed to load flag "' + Flag + '" as well as the default flag', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
248 |
copyToXY(flagsurf, texsurf, 2, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
249 |
SDL_FreeSurface(flagsurf); |
3513
f589230fa21b
now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents:
3509
diff
changeset
|
250 |
flagsurf:= nil; |
3697 | 251 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
252 |
// restore black border pixels inside the flag |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
253 |
PLongwordArray(texsurf^.pixels)^[32 * 2 + 2]:= cNearBlackColor; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
254 |
PLongwordArray(texsurf^.pixels)^[32 * 2 + 23]:= cNearBlackColor; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
255 |
PLongwordArray(texsurf^.pixels)^[32 * 16 + 2]:= cNearBlackColor; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
256 |
PLongwordArray(texsurf^.pixels)^[32 * 16 + 23]:= cNearBlackColor; |
2747 | 257 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
258 |
FlagTex:= Surface2Tex(texsurf, false); |
3041 | 259 |
SDL_FreeSurface(texsurf); |
260 |
||
3773 | 261 |
AIKillsTex := RenderStringTex(inttostr(stats.AIKills), Clan^.Color, fnt16); |
262 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
263 |
dec(drY, r.h + 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
264 |
DrawHealthY:= drY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
265 |
for i:= 0 to 7 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
266 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
267 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
268 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
269 |
NameTagTex:= RenderStringTex(Name, Clan^.Color, CheckCJKFont(Name,fnt16)); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
270 |
if Hat <> 'NoHat' then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
271 |
begin |
2874
3c7c2bf1ba38
A simple hat reservation mechanism. Can be worked around with a little effort, but to make it useful, you'd have to get everyone you played with to work around it too. Quite a bit of effort for a small reward feature.
nemo
parents:
2873
diff
changeset
|
272 |
if (Length(Hat) > 39) and (Copy(Hat,1,8) = 'Reserved') and (Copy(Hat,9,32) = PlayerHash) then |
3041 | 273 |
texsurf:= LoadImage(Pathz[ptHats] + '/Reserved/' + Copy(Hat,9,Length(s)-8), ifNone) |
2874
3c7c2bf1ba38
A simple hat reservation mechanism. Can be worked around with a little effort, but to make it useful, you'd have to get everyone you played with to work around it too. Quite a bit of effort for a small reward feature.
nemo
parents:
2873
diff
changeset
|
274 |
else |
3041 | 275 |
texsurf:= LoadImage(Pathz[ptHats] + '/' + Hat, ifNone); |
3862 | 276 |
if texsurf <> nil then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
277 |
begin |
3862 | 278 |
HatTex:= Surface2Tex(texsurf, true); |
279 |
SDL_FreeSurface(texsurf) |
|
3513
f589230fa21b
now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents:
3509
diff
changeset
|
280 |
end; |
3862 | 281 |
texsurf:= nil; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
282 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
283 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
284 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
285 |
MissionIcons:= LoadImage(Pathz[ptGraphics] + '/missions', ifCritical); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
286 |
iconsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, 28, 28, 32, RMask, GMask, BMask, AMask); |
3862 | 287 |
if iconsurf <> nil then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
288 |
begin |
3862 | 289 |
r.x:= 0; |
290 |
r.y:= 0; |
|
291 |
r.w:= 28; |
|
292 |
r.h:= 28; |
|
293 |
DrawRoundRect(@r, cWhiteColor, cNearBlackColor, iconsurf, true); |
|
294 |
ropeIconTex:= Surface2Tex(iconsurf, false); |
|
295 |
SDL_FreeSurface(iconsurf); |
|
296 |
iconsurf:= nil; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
297 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
298 |
end; |
4 | 299 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
300 |
procedure MakeCrossHairs; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
301 |
var t: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
302 |
tmpsurf, texsurf: PSDL_Surface; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
303 |
Color, i: Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
304 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
305 |
s:= Pathz[ptGraphics] + '/' + cCHFileName; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
306 |
tmpsurf:= LoadImage(s, ifAlpha or ifCritical); |
4 | 307 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
308 |
for t:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
309 |
with TeamsArray[t]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
310 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
311 |
texsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, tmpsurf^.w, tmpsurf^.h, 32, RMask, GMask, BMask, AMask); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
312 |
TryDo(texsurf <> nil, errmsgCreateSurface, true); |
764
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
313 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
314 |
Color:= Clan^.Color; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
315 |
Color:= SDL_MapRGB(texsurf^.format, Color shr 16, Color shr 8, Color and $FF); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
316 |
SDL_FillRect(texsurf, nil, Color); |
764
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
317 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
318 |
SDL_UpperBlit(tmpsurf, nil, texsurf, nil); |
777 | 319 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
320 |
TryDo(tmpsurf^.format^.BytesPerPixel = 4, 'Ooops', true); |
777 | 321 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
322 |
if SDL_MustLock(texsurf) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
323 |
SDLTry(SDL_LockSurface(texsurf) >= 0, true); |
777 | 324 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
325 |
// make black pixel be alpha-transparent |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
326 |
for i:= 0 to texsurf^.w * texsurf^.h - 1 do |
3862 | 327 |
if PLongwordArray(texsurf^.pixels)^[i] = AMask then PLongwordArray(texsurf^.pixels)^[i]:= (RMask or GMask or BMask) and Color; |
777 | 328 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
329 |
if SDL_MustLock(texsurf) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
330 |
SDL_UnlockSurface(texsurf); |
764
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
331 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
332 |
CrosshairTex:= Surface2Tex(texsurf, false); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
333 |
SDL_FreeSurface(texsurf) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
334 |
end; |
351 | 335 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
336 |
SDL_FreeSurface(tmpsurf) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
337 |
end; |
4 | 338 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
339 |
procedure InitHealth; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
340 |
var i, t: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
341 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
342 |
for t:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
343 |
if TeamsArray[t] <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
344 |
with TeamsArray[t]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
345 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
346 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
347 |
if Hedgehogs[i].Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
348 |
RenderHealth(Hedgehogs[i]); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
349 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
350 |
end; |
4 | 351 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
352 |
procedure LoadGraves; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
353 |
var t: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
354 |
texsurf: PSDL_Surface; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
355 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
356 |
for t:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
357 |
if TeamsArray[t] <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
358 |
with TeamsArray[t]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
359 |
begin |
3689 | 360 |
if GraveName = '' then GraveName:= 'Statue'; |
361 |
texsurf:= LoadImage(Pathz[ptGraves] + '/' + GraveName, ifTransparent); |
|
362 |
if texsurf = nil then texsurf:= LoadImage(Pathz[ptGraves] + '/Statue', ifCritical or ifTransparent); |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
363 |
GraveTex:= Surface2Tex(texsurf, false); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
364 |
SDL_FreeSurface(texsurf) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
365 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
366 |
end; |
4 | 367 |
|
844 | 368 |
var ii: TSprite; |
369 |
fi: THWFont; |
|
370 |
ai: TAmmoType; |
|
371 |
tmpsurf: PSDL_Surface; |
|
372 |
i: LongInt; |
|
4 | 373 |
begin |
2222 | 374 |
|
4 | 375 |
for fi:= Low(THWFont) to High(THWFont) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
376 |
with Fontz[fi] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
377 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
378 |
s:= Pathz[ptFonts] + '/' + Name; |
3185 | 379 |
WriteToConsole(msgLoading + s + ' (' + inttostr(Height) + 'pt)... '); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
380 |
Handle:= TTF_OpenFont(Str2PChar(s), Height); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
381 |
SDLTry(Handle <> nil, true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
382 |
TTF_SetFontStyle(Handle, style); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
383 |
WriteLnToConsole(msgOK) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
384 |
end; |
53 | 385 |
|
4 | 386 |
WriteNames(fnt16); |
70 | 387 |
MakeCrossHairs; |
4 | 388 |
LoadGraves; |
389 |
||
390 |
AddProgress; |
|
391 |
for ii:= Low(TSprite) to High(TSprite) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
392 |
with SpritesData[ii] do |
2145 | 393 |
// FIXME - add a sprite attribute |
3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3558
diff
changeset
|
394 |
if ((cReducedQuality and rqNoBackground) = 0) or (not (ii in [sprSky, sprSkyL, sprSkyR, sprHorizont, sprHorizontL, sprHorizontR, sprFlake, sprSplash, sprDroplet])) then // FIXME: hack |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
395 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
396 |
if AltPath = ptNone then |
3881
e570268a9d52
re-add City theme with the UpdateDataFolder script (and revert changes made to the flake sprite)
koda
parents:
3875
diff
changeset
|
397 |
if ii in [sprHorizontL, sprHorizontR, sprSkyL, sprSkyR] then // FIXME: hack |
3537
8f5b3108f29c
New approach to the low-res problem. Basically, we already have a 1024 minimum, and the tallest maps are restricting themselves to 2048 maximum. All backgrounds are scaled down 50%, then scaled up on draw. Saves memory, and backgrounds are already deliberately fuzzed for depth of field anyway.
nemo
parents:
3525
diff
changeset
|
398 |
tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, ifAlpha or ifTransparent) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
399 |
else |
3537
8f5b3108f29c
New approach to the low-res problem. Basically, we already have a 1024 minimum, and the tallest maps are restricting themselves to 2048 maximum. All backgrounds are scaled down 50%, then scaled up on draw. Saves memory, and backgrounds are already deliberately fuzzed for depth of field anyway.
nemo
parents:
3525
diff
changeset
|
400 |
tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, ifAlpha or ifTransparent or ifCritical) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
401 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
402 |
tmpsurf:= LoadImage(Pathz[Path] + '/' + FileName, ifAlpha or ifTransparent); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
403 |
if tmpsurf = nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
404 |
tmpsurf:= LoadImage(Pathz[AltPath] + '/' + FileName, ifAlpha or ifCritical or ifTransparent); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
405 |
end; |
2426 | 406 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
407 |
if tmpsurf <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
408 |
begin |
3558 | 409 |
if getImageDimensions then |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
410 |
begin |
3558 | 411 |
imageWidth:= tmpsurf^.w; |
412 |
imageHeight:= tmpsurf^.h |
|
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
413 |
end; |
3558 | 414 |
if getDimensions then |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
415 |
begin |
3558 | 416 |
Width:= tmpsurf^.w; |
417 |
Height:= tmpsurf^.h |
|
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
418 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
419 |
if (ii in [sprSky, sprSkyL, sprSkyR, sprHorizont, sprHorizontL, sprHorizontR]) then |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
420 |
begin |
3537
8f5b3108f29c
New approach to the low-res problem. Basically, we already have a 1024 minimum, and the tallest maps are restricting themselves to 2048 maximum. All backgrounds are scaled down 50%, then scaled up on draw. Saves memory, and backgrounds are already deliberately fuzzed for depth of field anyway.
nemo
parents:
3525
diff
changeset
|
421 |
Texture:= Surface2Tex(tmpsurf, true); |
8f5b3108f29c
New approach to the low-res problem. Basically, we already have a 1024 minimum, and the tallest maps are restricting themselves to 2048 maximum. All backgrounds are scaled down 50%, then scaled up on draw. Saves memory, and backgrounds are already deliberately fuzzed for depth of field anyway.
nemo
parents:
3525
diff
changeset
|
422 |
Texture^.Scale:= 2 |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
423 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
424 |
else |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
425 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
426 |
Texture:= Surface2Tex(tmpsurf, false); |
3611 | 427 |
if (ii = sprWater) and ((cReducedQuality and (rq2DWater or rqClampLess)) = 0) then // HACK: We should include some sprite attribute to define the texture wrap directions |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
428 |
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
429 |
end; |
3491 | 430 |
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, priority); |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
431 |
if saveSurf then |
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
432 |
Surface:= tmpsurf else SDL_FreeSurface(tmpsurf) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
433 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
434 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
435 |
Surface:= nil |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
436 |
end; |
80 | 437 |
|
4 | 438 |
AddProgress; |
567 | 439 |
|
2171
8208946331ba
Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents:
2161
diff
changeset
|
440 |
tmpsurf:= LoadImage(Pathz[ptGraphics] + '/' + cHHFileName, ifAlpha or ifCritical or ifTransparent); |
2290
bf87ca44782e
Selectively enable clamping - seeing if this helps avoid weird flake problems while still fixing vertical lines in waves and sky
nemo
parents:
2285
diff
changeset
|
441 |
HHTexture:= Surface2Tex(tmpsurf, false); |
761 | 442 |
SDL_FreeSurface(tmpsurf); |
4 | 443 |
|
444 |
InitHealth; |
|
445 |
||
3774 | 446 |
// TODO: are those textures ever freed? |
2623 | 447 |
PauseTexture:= RenderStringTex(trmsg[sidPaused], cYellowColor, fntBig); |
448 |
ConfirmTexture:= RenderStringTex(trmsg[sidConfirm], cYellowColor, fntBig); |
|
449 |
SyncTexture:= RenderStringTex(trmsg[sidSync], cYellowColor, fntBig); |
|
281
5b483aa9f2ab
Pause support (mouse cursor is released when the game is paused)
unc0rr
parents:
208
diff
changeset
|
450 |
|
2601 | 451 |
AddProgress; |
452 |
||
2670 | 453 |
// name of weapons in ammo menu |
843 | 454 |
for ai:= Low(TAmmoType) to High(TAmmoType) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
455 |
with Ammoz[ai] do |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
456 |
begin |
3384 | 457 |
TryDo(trAmmo[NameId] <> '','No default text/translation found for ammo type #' + intToStr(ord(ai)) + '!',true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
458 |
tmpsurf:= TTF_RenderUTF8_Blended(Fontz[CheckCJKFont(trAmmo[NameId],fnt16)].Handle, Str2PChar(trAmmo[NameId]), cWhiteColorChannels); |
3384 | 459 |
TryDo(tmpsurf <> nil,'Name-texture creation for ammo type #' + intToStr(ord(ai)) + ' failed!',true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
460 |
tmpsurf:= doSurfaceConversion(tmpsurf); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
461 |
NameTex:= Surface2Tex(tmpsurf, false); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
462 |
SDL_FreeSurface(tmpsurf) |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
463 |
end; |
2376 | 464 |
|
2670 | 465 |
// number of weapons in ammo menu |
844 | 466 |
for i:= Low(CountTexz) to High(CountTexz) do |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
467 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
468 |
tmpsurf:= TTF_RenderUTF8_Blended(Fontz[fnt16].Handle, Str2PChar(IntToStr(i) + 'x'), cWhiteColorChannels); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
469 |
tmpsurf:= doSurfaceConversion(tmpsurf); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
470 |
CountTexz[i]:= Surface2Tex(tmpsurf, false); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
471 |
SDL_FreeSurface(tmpsurf) |
3765
ebfe7c9b3085
set flake to non critical, no touches until game is starding, moved some variables to be initialized in the right place
koda
parents:
3764
diff
changeset
|
472 |
end; |
844 | 473 |
|
2222 | 474 |
AddProgress; |
2669 | 475 |
|
2672 | 476 |
{$IFDEF SDL_IMAGE_NEWER} |
2669 | 477 |
IMG_Quit(); |
2671
7e0f88013fe8
smaller patches, one missing Sky-lowres, IMG_Init and Mix_Init (might require newer libraries), updates to SDL bindings, code cleanup, new compile flags
koda
parents:
2670
diff
changeset
|
478 |
{$ENDIF} |
4 | 479 |
end; |
480 |
||
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
481 |
procedure DrawFromRect(X, Y: LongInt; r: PSDL_Rect; SourceTexture: PTexture); |
2958 | 482 |
begin |
483 |
DrawFromRect(X, Y, r^.w, r^.h, r, SourceTexture) |
|
484 |
end; |
|
485 |
||
486 |
procedure DrawFromRect(X, Y, W, H: LongInt; r: PSDL_Rect; SourceTexture: PTexture); |
|
4 | 487 |
var rr: TSDL_Rect; |
764
7513452b1d51
Now game looks almost like it did before switching to OpenGL
unc0rr
parents:
762
diff
changeset
|
488 |
_l, _r, _t, _b: real; |
1916 | 489 |
VertexBuffer, TextureBuffer: array [0..3] of TVertex2f; |
4 | 490 |
begin |
3881
e570268a9d52
re-add City theme with the UpdateDataFolder script (and revert changes made to the flake sprite)
koda
parents:
3875
diff
changeset
|
491 |
if (SourceTexture^.h = 0) or (SourceTexture^.w = 0) then exit; |
3764 | 492 |
|
493 |
// don't draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs) |
|
494 |
if (abs(X) > W) and ((abs(X + W / 2) - W / 2) > cScreenWidth / cScaleFactor) then |
|
495 |
exit; |
|
496 |
if (abs(Y) > H) and ((abs(Y + H / 2 - (0.5 * cScreenHeight)) - H / 2) > cScreenHeight / cScaleFactor) then |
|
497 |
exit; |
|
498 |
||
4 | 499 |
rr.x:= X; |
500 |
rr.y:= Y; |
|
2958 | 501 |
rr.w:= W; |
502 |
rr.h:= H; |
|
755 | 503 |
|
1896 | 504 |
_l:= r^.x / SourceTexture^.w * SourceTexture^.rx; |
505 |
_r:= (r^.x + r^.w) / SourceTexture^.w * SourceTexture^.rx; |
|
506 |
_t:= r^.y / SourceTexture^.h * SourceTexture^.ry; |
|
507 |
_b:= (r^.y + r^.h) / SourceTexture^.h * SourceTexture^.ry; |
|
755 | 508 |
|
509 |
glBindTexture(GL_TEXTURE_2D, SourceTexture^.id); |
|
510 |
||
1916 | 511 |
VertexBuffer[0].X:= X; |
512 |
VertexBuffer[0].Y:= Y; |
|
513 |
VertexBuffer[1].X:= rr.w + X; |
|
514 |
VertexBuffer[1].Y:= Y; |
|
515 |
VertexBuffer[2].X:= rr.w + X; |
|
516 |
VertexBuffer[2].Y:= rr.h + Y; |
|
517 |
VertexBuffer[3].X:= X; |
|
518 |
VertexBuffer[3].Y:= rr.h + Y; |
|
755 | 519 |
|
1916 | 520 |
TextureBuffer[0].X:= _l; |
521 |
TextureBuffer[0].Y:= _t; |
|
522 |
TextureBuffer[1].X:= _r; |
|
523 |
TextureBuffer[1].Y:= _t; |
|
524 |
TextureBuffer[2].X:= _r; |
|
525 |
TextureBuffer[2].Y:= _b; |
|
526 |
TextureBuffer[3].X:= _l; |
|
527 |
TextureBuffer[3].Y:= _b; |
|
755 | 528 |
|
529 |
||
1916 | 530 |
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); |
531 |
glTexCoordPointer(2, GL_FLOAT, 0, @TextureBuffer[0]); |
|
532 |
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); |
|
762 | 533 |
end; |
534 |
||
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3491
diff
changeset
|
535 |
procedure DrawTexture(X, Y: LongInt; Texture: PTexture; Scale: GLfloat); |
762 | 536 |
begin |
3764 | 537 |
|
1904 | 538 |
glPushMatrix; |
539 |
glTranslatef(X, Y, 0); |
|
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3491
diff
changeset
|
540 |
glScalef(Scale, Scale, 1); |
1904 | 541 |
|
762 | 542 |
glBindTexture(GL_TEXTURE_2D, Texture^.id); |
543 |
||
1912
c3d31fb59f0e
Save much CPU time by initializing vertex arrays in texture creation function
unc0rr
parents:
1908
diff
changeset
|
544 |
glVertexPointer(2, GL_FLOAT, 0, @Texture^.vb); |
c3d31fb59f0e
Save much CPU time by initializing vertex arrays in texture creation function
unc0rr
parents:
1908
diff
changeset
|
545 |
glTexCoordPointer(2, GL_FLOAT, 0, @Texture^.tb); |
c3d31fb59f0e
Save much CPU time by initializing vertex arrays in texture creation function
unc0rr
parents:
1908
diff
changeset
|
546 |
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(Texture^.vb)); |
1904 | 547 |
|
548 |
glPopMatrix |
|
4 | 549 |
end; |
550 |
||
2811 | 551 |
procedure DrawTextureF(Texture: PTexture; Scale: GLfloat; X, Y, Frame, Dir, w, h: LongInt); |
1242 | 552 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
553 |
DrawRotatedTextureF(Texture, Scale, 0, 0, X, Y, Frame, Dir, w, h, 0) |
2597 | 554 |
end; |
555 |
||
2811 | 556 |
procedure DrawRotatedTextureF(Texture: PTexture; Scale, OffsetX, OffsetY: GLfloat; X, Y, Frame, Dir, w, h: LongInt; Angle: real); |
557 |
var ft, fb, fl, fr: GLfloat; |
|
558 |
hw, nx, ny: LongInt; |
|
2597 | 559 |
VertexBuffer, TextureBuffer: array [0..3] of TVertex2f; |
560 |
begin |
|
3764 | 561 |
// don't draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs) |
3938 | 562 |
if (abs(X) > W) and ((abs(X + dir * OffsetX) - W / 2) * cScaleFactor > cScreenWidth) then |
3764 | 563 |
exit; |
3938 | 564 |
if (abs(Y) > H) and ((abs(Y + OffsetY - (0.5 * cScreenHeight)) - W / 2) * cScaleFactor > cScreenHeight) then |
3764 | 565 |
exit; |
566 |
||
2597 | 567 |
glPushMatrix; |
568 |
glTranslatef(X, Y, 0); |
|
569 |
||
570 |
if Dir < 0 then |
|
571 |
glRotatef(Angle, 0, 0, -1) |
|
572 |
else |
|
573 |
glRotatef(Angle, 0, 0, 1); |
|
574 |
||
575 |
glTranslatef(Dir*OffsetX, OffsetY, 0); |
|
2811 | 576 |
glScalef(Scale, Scale, 1); |
577 |
||
3376 | 578 |
// Any reason for this call? And why only in t direction, not s? |
579 |
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
|
1242 | 580 |
|
581 |
if Dir < 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
582 |
hw:= w div -2 |
1242 | 583 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
584 |
hw:= w div 2; |
2811 | 585 |
|
2910 | 586 |
nx:= round(Texture^.w / w); // number of horizontal frames |
587 |
ny:= round(Texture^.h / h); // number of vertical frames |
|
1242 | 588 |
|
2910 | 589 |
ft:= (Frame mod ny) * Texture^.ry / ny; |
590 |
fb:= ((Frame mod ny) + 1) * Texture^.ry / ny; |
|
591 |
fl:= (Frame div ny) * Texture^.rx / nx; |
|
592 |
fr:= ((Frame div ny) + 1) * Texture^.rx / nx; |
|
1242 | 593 |
|
594 |
glBindTexture(GL_TEXTURE_2D, Texture^.id); |
|
595 |
||
1916 | 596 |
VertexBuffer[0].X:= -hw; |
2811 | 597 |
VertexBuffer[0].Y:= w / -2; |
1916 | 598 |
VertexBuffer[1].X:= hw; |
2811 | 599 |
VertexBuffer[1].Y:= w / -2; |
1916 | 600 |
VertexBuffer[2].X:= hw; |
2811 | 601 |
VertexBuffer[2].Y:= w / 2; |
1916 | 602 |
VertexBuffer[3].X:= -hw; |
2811 | 603 |
VertexBuffer[3].Y:= w / 2; |
1242 | 604 |
|
2811 | 605 |
TextureBuffer[0].X:= fl; |
1916 | 606 |
TextureBuffer[0].Y:= ft; |
2811 | 607 |
TextureBuffer[1].X:= fr; |
1916 | 608 |
TextureBuffer[1].Y:= ft; |
2811 | 609 |
TextureBuffer[2].X:= fr; |
1916 | 610 |
TextureBuffer[2].Y:= fb; |
2811 | 611 |
TextureBuffer[3].X:= fl; |
1916 | 612 |
TextureBuffer[3].Y:= fb; |
1242 | 613 |
|
1916 | 614 |
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); |
615 |
glTexCoordPointer(2, GL_FLOAT, 0, @TextureBuffer[0]); |
|
616 |
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); |
|
617 |
||
1242 | 618 |
glPopMatrix |
619 |
end; |
|
620 |
||
822 | 621 |
procedure DrawRotated(Sprite: TSprite; X, Y, Dir: LongInt; Angle: real); |
775 | 622 |
begin |
3405 | 623 |
DrawRotatedTex(SpritesData[Sprite].Texture, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
624 |
SpritesData[Sprite].Width, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
625 |
SpritesData[Sprite].Height, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
626 |
X, Y, Dir, Angle) |
777 | 627 |
end; |
628 |
||
853 | 629 |
procedure DrawRotatedF(Sprite: TSprite; X, Y, Frame, Dir: LongInt; Angle: real); |
806 | 630 |
begin |
631 |
glPushMatrix; |
|
809 | 632 |
glTranslatef(X, Y, 0); |
806 | 633 |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
634 |
if Dir < 0 then |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
635 |
glRotatef(Angle, 0, 0, -1) |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
636 |
else |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
637 |
glRotatef(Angle, 0, 0, 1); |
853 | 638 |
if Dir < 0 then glScalef(-1.0, 1.0, 1.0); |
639 |
||
640 |
DrawSprite(Sprite, -SpritesData[Sprite].Width div 2, -SpritesData[Sprite].Height div 2, Frame); |
|
806 | 641 |
|
642 |
glPopMatrix |
|
643 |
end; |
|
644 |
||
822 | 645 |
procedure DrawRotatedTex(Tex: PTexture; hw, hh, X, Y, Dir: LongInt; Angle: real); |
1916 | 646 |
var VertexBuffer: array [0..3] of TVertex2f; |
777 | 647 |
begin |
3764 | 648 |
// don't draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs) |
649 |
if (abs(X) > 2 * hw) and ((abs(X) - hw) > cScreenWidth / cScaleFactor) then |
|
650 |
exit; |
|
651 |
if (abs(Y) > 2 * hh) and ((abs(Y - 0.5 * cScreenHeight) - hh) > cScreenHeight / cScaleFactor) then |
|
652 |
exit; |
|
653 |
||
775 | 654 |
glPushMatrix; |
655 |
glTranslatef(X, Y, 0); |
|
822 | 656 |
|
657 |
if Dir < 0 then |
|
658 |
begin |
|
659 |
hw:= - hw; |
|
660 |
glRotatef(Angle, 0, 0, -1); |
|
661 |
end else |
|
662 |
glRotatef(Angle, 0, 0, 1); |
|
663 |
||
775 | 664 |
|
777 | 665 |
glBindTexture(GL_TEXTURE_2D, Tex^.id); |
775 | 666 |
|
1916 | 667 |
VertexBuffer[0].X:= -hw; |
668 |
VertexBuffer[0].Y:= -hh; |
|
669 |
VertexBuffer[1].X:= hw; |
|
670 |
VertexBuffer[1].Y:= -hh; |
|
671 |
VertexBuffer[2].X:= hw; |
|
672 |
VertexBuffer[2].Y:= hh; |
|
673 |
VertexBuffer[3].X:= -hw; |
|
674 |
VertexBuffer[3].Y:= hh; |
|
775 | 675 |
|
1916 | 676 |
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); |
677 |
glTexCoordPointer(2, GL_FLOAT, 0, @Tex^.tb); |
|
678 |
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); |
|
775 | 679 |
|
680 |
glPopMatrix |
|
681 |
end; |
|
682 |
||
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
683 |
procedure DrawSpriteFromRect(Sprite: TSprite; r: TSDL_Rect; X, Y, Height, Position: LongInt); |
4 | 684 |
begin |
685 |
r.y:= r.y + Height * Position; |
|
686 |
r.h:= Height; |
|
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
687 |
DrawFromRect(X, Y, @r, SpritesData[Sprite].Texture) |
4 | 688 |
end; |
689 |
||
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
690 |
procedure DrawSprite (Sprite: TSprite; X, Y, Frame: LongInt); |
2229
081081a61a16
patch for loading sprites on two columns (helps embedded and lowpower machines). must deal with amGirder.png
koda
parents:
2227
diff
changeset
|
691 |
var row, col, numFramesFirstCol: LongInt; |
4 | 692 |
begin |
2229
081081a61a16
patch for loading sprites on two columns (helps embedded and lowpower machines). must deal with amGirder.png
koda
parents:
2227
diff
changeset
|
693 |
numFramesFirstCol:= SpritesData[Sprite].imageHeight div SpritesData[Sprite].Height; |
081081a61a16
patch for loading sprites on two columns (helps embedded and lowpower machines). must deal with amGirder.png
koda
parents:
2227
diff
changeset
|
694 |
row:= Frame mod numFramesFirstCol; |
081081a61a16
patch for loading sprites on two columns (helps embedded and lowpower machines). must deal with amGirder.png
koda
parents:
2227
diff
changeset
|
695 |
col:= Frame div numFramesFirstCol; |
081081a61a16
patch for loading sprites on two columns (helps embedded and lowpower machines). must deal with amGirder.png
koda
parents:
2227
diff
changeset
|
696 |
DrawSprite2 (Sprite, X, Y, col, row); |
4 | 697 |
end; |
698 |
||
1939 | 699 |
procedure DrawSpriteClipped(Sprite: TSprite; X, Y, TopY, RightX, BottomY, LeftX: LongInt); |
700 |
var r: TSDL_Rect; |
|
701 |
begin |
|
702 |
r.x:= 0; |
|
703 |
r.y:= 0; |
|
704 |
r.w:= SpritesData[Sprite].Width; |
|
705 |
r.h:= SpritesData[Sprite].Height; |
|
706 |
||
707 |
if (X < LeftX) then |
|
708 |
r.x:= LeftX - X; |
|
709 |
if (Y < TopY) then |
|
710 |
r.y:= TopY - Y; |
|
711 |
||
712 |
if (Y + SpritesData[Sprite].Height > BottomY) then |
|
713 |
r.h:= BottomY - Y + 1; |
|
714 |
if (X + SpritesData[Sprite].Width > RightX) then |
|
715 |
r.w:= RightX - X + 1; |
|
716 |
||
717 |
dec(r.h, r.y); |
|
718 |
dec(r.w, r.x); |
|
2230
d6963f72d21a
once again, trying to restore windows compatibility from nemo's experiments
koda
parents:
2229
diff
changeset
|
719 |
|
1939 | 720 |
DrawFromRect(X + r.x, Y + r.y, @r, SpritesData[Sprite].Texture) |
721 |
end; |
|
722 |
||
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset
|
723 |
procedure DrawSprite2(Sprite: TSprite; X, Y, FrameX, FrameY: LongInt); |
43 | 724 |
var r: TSDL_Rect; |
725 |
begin |
|
3405 | 726 |
r.x:= FrameX * SpritesData[Sprite].Width; |
727 |
r.w:= SpritesData[Sprite].Width; |
|
728 |
r.y:= FrameY * SpritesData[Sprite].Height; |
|
729 |
r.h:= SpritesData[Sprite].Height; |
|
730 |
DrawFromRect(X, Y, @r, SpritesData[Sprite].Texture) |
|
43 | 731 |
end; |
732 |
||
762 | 733 |
procedure DrawCentered(X, Top: LongInt; Source: PTexture); |
3895
e7c202c08ac1
compilation bugfix and scaling down textures when bigger than screen
koda
parents:
3881
diff
changeset
|
734 |
var scale: GLfloat; |
95 | 735 |
begin |
3895
e7c202c08ac1
compilation bugfix and scaling down textures when bigger than screen
koda
parents:
3881
diff
changeset
|
736 |
if (Source^.w + 20) > cScreenWidth then |
e7c202c08ac1
compilation bugfix and scaling down textures when bigger than screen
koda
parents:
3881
diff
changeset
|
737 |
scale:= cScreenWidth / (Source^.w + 20) |
e7c202c08ac1
compilation bugfix and scaling down textures when bigger than screen
koda
parents:
3881
diff
changeset
|
738 |
else |
e7c202c08ac1
compilation bugfix and scaling down textures when bigger than screen
koda
parents:
3881
diff
changeset
|
739 |
scale:= 1.0; |
3897
27e115fa1143
captions are scaled down when they're bigger than screen
koda
parents:
3895
diff
changeset
|
740 |
DrawTexture(X - round(Source^.w * scale) div 2, Top, Source, scale) |
4 | 741 |
end; |
742 |
||
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1854
diff
changeset
|
743 |
procedure DrawHedgehog(X, Y: LongInt; Dir: LongInt; Pos, Step: LongWord; Angle: real); |
1916 | 744 |
const VertexBuffer: array [0..3] of TVertex2f = ( |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
745 |
(x: -16; y: -16), |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
746 |
(x: 16; y: -16), |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
747 |
(x: 16; y: 16), |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
748 |
(x: -16; y: 16)); |
761 | 749 |
var l, r, t, b: real; |
1916 | 750 |
TextureBuffer: array [0..3] of TVertex2f; |
4 | 751 |
begin |
3764 | 752 |
// don't draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs) |
3938 | 753 |
if (abs(X) > 32) and ((abs(X) - 16) * cScaleFactor > cScreenWidth) then |
3764 | 754 |
exit; |
3938 | 755 |
if (abs(Y) > 32) and ((abs(Y - 0.5 * cScreenHeight) - 16) * cScaleFactor > cScreenHeight) then |
3764 | 756 |
exit; |
761 | 757 |
|
758 |
t:= Pos * 32 / HHTexture^.h; |
|
759 |
b:= (Pos + 1) * 32 / HHTexture^.h; |
|
760 |
||
761 |
if Dir = -1 then |
|
762 |
begin |
|
763 |
l:= (Step + 1) * 32 / HHTexture^.w; |
|
764 |
r:= Step * 32 / HHTexture^.w |
|
765 |
end else |
|
766 |
begin |
|
767 |
l:= Step * 32 / HHTexture^.w; |
|
768 |
r:= (Step + 1) * 32 / HHTexture^.w |
|
769 |
end; |
|
770 |
||
821
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
809
diff
changeset
|
771 |
|
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
809
diff
changeset
|
772 |
glPushMatrix(); |
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
809
diff
changeset
|
773 |
glTranslatef(X, Y, 0); |
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
809
diff
changeset
|
774 |
glRotatef(Angle, 0, 0, 1); |
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
809
diff
changeset
|
775 |
|
761 | 776 |
glBindTexture(GL_TEXTURE_2D, HHTexture^.id); |
777 |
||
1916 | 778 |
TextureBuffer[0].X:= l; |
779 |
TextureBuffer[0].Y:= t; |
|
780 |
TextureBuffer[1].X:= r; |
|
781 |
TextureBuffer[1].Y:= t; |
|
782 |
TextureBuffer[2].X:= r; |
|
783 |
TextureBuffer[2].Y:= b; |
|
784 |
TextureBuffer[3].X:= l; |
|
785 |
TextureBuffer[3].Y:= b; |
|
761 | 786 |
|
1916 | 787 |
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); |
788 |
glTexCoordPointer(2, GL_FLOAT, 0, @TextureBuffer[0]); |
|
789 |
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); |
|
761 | 790 |
|
821
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
809
diff
changeset
|
791 |
glPopMatrix |
4 | 792 |
end; |
793 |
||
1431 | 794 |
procedure DrawFillRect(r: TSDL_Rect); |
1916 | 795 |
var VertexBuffer: array [0..3] of TVertex2f; |
1431 | 796 |
begin |
3764 | 797 |
// don't draw anything outside the visible screen space (first check fixes some sprite drawing, e.g. hedgehogs) |
3938 | 798 |
if (abs(r.x) > r.w) and ((abs(r.x + r.w / 2) - r.w / 2) * cScaleFactor > cScreenWidth) then |
3764 | 799 |
exit; |
3938 | 800 |
if (abs(r.y) > r.h) and ((abs(r.y + r.h / 2 - (0.5 * cScreenHeight)) - r.h / 2) * cScaleFactor > cScreenHeight) then |
3764 | 801 |
exit; |
802 |
||
1431 | 803 |
glDisable(GL_TEXTURE_2D); |
804 |
||
3390 | 805 |
Tint($00, $00, $00, $80); |
1431 | 806 |
|
1916 | 807 |
VertexBuffer[0].X:= r.x; |
808 |
VertexBuffer[0].Y:= r.y; |
|
809 |
VertexBuffer[1].X:= r.x + r.w; |
|
810 |
VertexBuffer[1].Y:= r.y; |
|
811 |
VertexBuffer[2].X:= r.x + r.w; |
|
812 |
VertexBuffer[2].Y:= r.y + r.h; |
|
813 |
VertexBuffer[3].X:= r.x; |
|
814 |
VertexBuffer[3].Y:= r.y + r.h; |
|
1431 | 815 |
|
1916 | 816 |
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); |
817 |
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); |
|
1431 | 818 |
|
3390 | 819 |
Tint($FF, $FF, $FF, $FF); |
1431 | 820 |
glEnable(GL_TEXTURE_2D) |
821 |
end; |
|
822 |
||
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
823 |
procedure DrawCircle(X, Y, Radius: LongInt; Width: Single; r, g, b, a: Byte); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
824 |
var |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
825 |
i: LongInt; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
826 |
CircleVertex: array [0..359] of TVertex2f; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
827 |
begin |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
828 |
for i := 0 to 359 do begin |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
829 |
CircleVertex[i].X := X + Radius*cos(i*pi/180); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
830 |
CircleVertex[i].Y := Y + Radius*sin(i*pi/180); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
831 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
832 |
glDisable(GL_TEXTURE_2D); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
833 |
glEnable(GL_LINE_SMOOTH); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
834 |
glPushMatrix; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
835 |
glTranslatef(WorldDx, WorldDy, 0); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
836 |
glLineWidth(Width); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
837 |
Tint(r, g, b, a); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
838 |
glVertexPointer(2, GL_FLOAT, 0, @CircleVertex[0]); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
839 |
glDrawArrays(GL_LINE_LOOP, 0, 360); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
840 |
Tint($FF, $FF, $FF, $FF); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
841 |
glPopMatrix; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
842 |
glEnable(GL_TEXTURE_2D); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
843 |
glDisable(GL_LINE_SMOOTH); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
844 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3940
diff
changeset
|
845 |
|
4 | 846 |
procedure StoreRelease; |
847 |
var ii: TSprite; |
|
848 |
begin |
|
3405 | 849 |
for ii:= Low(TSprite) to High(TSprite) do |
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
850 |
begin |
3405 | 851 |
FreeTexture(SpritesData[ii].Texture); |
3513
f589230fa21b
now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents:
3509
diff
changeset
|
852 |
SpritesData[ii].Texture:= nil; |
3405 | 853 |
if SpritesData[ii].Surface <> nil then |
3513
f589230fa21b
now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents:
3509
diff
changeset
|
854 |
SDL_FreeSurface(SpritesData[ii].Surface); |
f589230fa21b
now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents:
3509
diff
changeset
|
855 |
SpritesData[ii].Surface:= nil; |
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
856 |
end; |
3405 | 857 |
SDL_FreeSurface(MissionIcons); |
858 |
FreeTexture(ropeIconTex); |
|
859 |
FreeTexture(HHTexture); |
|
4 | 860 |
end; |
861 |
||
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
862 |
|
2905 | 863 |
function CheckCJKFont(s: ansistring; font: THWFont): THWFont; |
2681
dcbb5e98afc7
Drop the LongInt conversion, strip the two tests that are too large
nemo
parents:
2679
diff
changeset
|
864 |
var l, i : LongInt; |
dcbb5e98afc7
Drop the LongInt conversion, strip the two tests that are too large
nemo
parents:
2679
diff
changeset
|
865 |
u: WideChar; |
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
866 |
tmpstr: array[0..256] of WideChar; |
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
867 |
begin |
3875
7d7c16ed5056
added forgotten images, removed support for CJK fonts (saving 13 MB)
koda
parents:
3862
diff
changeset
|
868 |
|
7d7c16ed5056
added forgotten images, removed support for CJK fonts (saving 13 MB)
koda
parents:
3862
diff
changeset
|
869 |
{$IFNDEF IPHONEOS} |
7d7c16ed5056
added forgotten images, removed support for CJK fonts (saving 13 MB)
koda
parents:
3862
diff
changeset
|
870 |
// remove chinese fonts for now |
7d7c16ed5056
added forgotten images, removed support for CJK fonts (saving 13 MB)
koda
parents:
3862
diff
changeset
|
871 |
if (font >= CJKfnt16) or (length(s) = 0) then |
7d7c16ed5056
added forgotten images, removed support for CJK fonts (saving 13 MB)
koda
parents:
3862
diff
changeset
|
872 |
{$ENDIF} |
7d7c16ed5056
added forgotten images, removed support for CJK fonts (saving 13 MB)
koda
parents:
3862
diff
changeset
|
873 |
exit(font); |
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
874 |
|
2684
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
875 |
l:= Utf8ToUnicode(@tmpstr, Str2PChar(s), length(s))-1; |
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
876 |
i:= 0; |
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
877 |
while i < l do |
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
878 |
begin |
2681
dcbb5e98afc7
Drop the LongInt conversion, strip the two tests that are too large
nemo
parents:
2679
diff
changeset
|
879 |
u:= tmpstr[i]; |
dcbb5e98afc7
Drop the LongInt conversion, strip the two tests that are too large
nemo
parents:
2679
diff
changeset
|
880 |
if (#$2E80 <= u) and ( |
2684
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
881 |
(u <= #$2FDF ) or // CJK Radicals Supplement / Kangxi Radicals |
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
882 |
((#$2FF0 <= u) and (u <= #$303F)) or // Ideographic Description Characters / CJK Radicals Supplement |
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
883 |
((#$31C0 <= u) and (u <= #$31EF)) or // CJK Strokes |
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
884 |
((#$3200 <= u) and (u <= #$4DBF)) or // Enclosed CJK Letters and Months / CJK Compatibility / CJK Unified Ideographs Extension A |
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
885 |
((#$4E00 <= u) and (u <= #$9FFF)) or // CJK Unified Ideographs |
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
886 |
((#$F900 <= u) and (u <= #$FAFF)) or // CJK Compatibility Ideographs |
04c086d8d9d4
Hopefully this is the last error. Fix the if test, offset by -1 due to how the output appears to be handled.
nemo
parents:
2681
diff
changeset
|
887 |
((#$FE30 <= u) and (u <= #$FE4F))) // CJK Compatibility Forms |
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
888 |
then exit(THWFont( ord(font) + ((ord(High(THWFont))+1) div 2) )); |
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
889 |
inc(i) |
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
890 |
end; |
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
891 |
exit(font); |
2681
dcbb5e98afc7
Drop the LongInt conversion, strip the two tests that are too large
nemo
parents:
2679
diff
changeset
|
892 |
(* two more to check. pascal WideChar is only 16 bit though |
dcbb5e98afc7
Drop the LongInt conversion, strip the two tests that are too large
nemo
parents:
2679
diff
changeset
|
893 |
((#$20000 <= u) and (u >= #$2A6DF)) or // CJK Unified Ideographs Extension B |
dcbb5e98afc7
Drop the LongInt conversion, strip the two tests that are too large
nemo
parents:
2679
diff
changeset
|
894 |
((#$2F800 <= u) and (u >= #$2FA1F))) // CJK Compatibility Ideographs Supplement *) |
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
895 |
end; |
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
896 |
|
2905 | 897 |
function RenderStringTex(s: ansistring; Color: Longword; font: THWFont): PTexture; |
3407 | 898 |
var w, h: LongInt; |
2695 | 899 |
finalSurface: PSDL_Surface; |
95 | 900 |
begin |
1989 | 901 |
if length(s) = 0 then s:= ' '; |
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
902 |
font:= CheckCJKFont(s, font); |
3407 | 903 |
w:= 0; h:= 0; // avoid compiler hints |
355 | 904 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(s), w, h); |
785 | 905 |
|
2695 | 906 |
finalSurface:= SDL_CreateRGBSurface(SDL_SWSURFACE, w + FontBorder * 2 + 4, h + FontBorder * 2, |
762 | 907 |
32, RMask, GMask, BMask, AMask); |
785 | 908 |
|
2695 | 909 |
TryDo(finalSurface <> nil, 'RenderString: fail to create surface', true); |
785 | 910 |
|
2695 | 911 |
WriteInRoundRect(finalSurface, 0, 0, Color, font, s); |
785 | 912 |
|
2695 | 913 |
TryDo(SDL_SetColorKey(finalSurface, SDL_SRCCOLORKEY, 0) = 0, errmsgTransparentSet, true); |
785 | 914 |
|
2695 | 915 |
RenderStringTex:= Surface2Tex(finalSurface, false); |
785 | 916 |
|
2695 | 917 |
SDL_FreeSurface(finalSurface); |
95 | 918 |
end; |
919 |
||
2905 | 920 |
function RenderSpeechBubbleTex(s: ansistring; SpeechType: Longword; font: THWFont): PTexture; |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
921 |
var textWidth, textHeight, x, y, w, h, i, j, pos, prevpos, line, numLines, edgeWidth, edgeHeight, cornerWidth, cornerHeight: LongInt; |
2695 | 922 |
finalSurface, tmpsurf, rotatedEdge: PSDL_Surface; |
2017 | 923 |
rect: TSDL_Rect; |
924 |
chars: TSysCharSet = [#9,' ','.',';',':','?','!',',']; |
|
925 |
substr: shortstring; |
|
926 |
edge, corner, tail: TSPrite; |
|
927 |
begin |
|
928 |
||
929 |
case SpeechType of |
|
2376 | 930 |
1: begin; |
931 |
edge:= sprSpeechEdge; |
|
2017 | 932 |
corner:= sprSpeechCorner; |
933 |
tail:= sprSpeechTail; |
|
934 |
end; |
|
2376 | 935 |
2: begin; |
2017 | 936 |
edge:= sprThoughtEdge; |
2376 | 937 |
corner:= sprThoughtCorner; |
2017 | 938 |
tail:= sprThoughtTail; |
939 |
end; |
|
2376 | 940 |
3: begin; |
2017 | 941 |
edge:= sprShoutEdge; |
942 |
corner:= sprShoutCorner; |
|
943 |
tail:= sprShoutTail; |
|
944 |
end; |
|
945 |
end; |
|
946 |
edgeHeight:= SpritesData[edge].Height; |
|
947 |
edgeWidth:= SpritesData[edge].Width; |
|
948 |
cornerWidth:= SpritesData[corner].Width; |
|
949 |
cornerHeight:= SpritesData[corner].Height; |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
950 |
// This one screws up WrapText |
2022 | 951 |
//s:= 'This is the song that never ends. ''cause it goes on and on my friends. Some people, started singing it not knowing what it was. And they''ll just go on singing it forever just because... This is the song that never ends...'; |
2154
3d2917be12c3
Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents:
2153
diff
changeset
|
952 |
// This one does not |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
953 |
//s:= 'This is the song that never ends. cause it goes on and on my friends. Some people, started singing it not knowing what it was. And they will go on singing it forever just because... This is the song that never ends... '; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
954 |
|
2022 | 955 |
numLines:= 0; |
2017 | 956 |
|
957 |
if length(s) = 0 then s:= '...'; |
|
2677
83ad68ceef72
Non-hacked version of CJK handling. Should switch to CJK rendering only if a particular string needs it, instead of based on locale file.
nemo
parents:
2674
diff
changeset
|
958 |
font:= CheckCJKFont(s, font); |
3407 | 959 |
w:= 0; h:= 0; // avoid compiler hints |
2017 | 960 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(s), w, h); |
2332
351abbbb12f3
Lower bound on speech text width for proper rendering
nemo
parents:
2292
diff
changeset
|
961 |
if w<8 then w:= 8; |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
962 |
j:= 0; |
2017 | 963 |
if (length(s) > 20) then |
964 |
begin |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
965 |
w:= 0; |
2017 | 966 |
i:= round(Sqrt(length(s)) * 2); |
967 |
s:= WrapText(s, #1, chars, i); |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
968 |
pos:= 1; prevpos:= 0; line:= 0; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
969 |
// Find the longest line for the purposes of centring the text. Font dependant. |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
970 |
while pos <= length(s) do |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
971 |
begin |
2017 | 972 |
if (s[pos] = #1) or (pos = length(s)) then |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
973 |
begin |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
974 |
inc(numlines); |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
975 |
if s[pos] <> #1 then inc(pos); |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
976 |
while s[prevpos+1] = ' ' do inc(prevpos); |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
977 |
substr:= copy(s, prevpos+1, pos-prevpos-1); |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
978 |
i:= 0; j:= 0; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
979 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(substr), i, j); |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
980 |
if i > w then w:= i; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
981 |
prevpos:= pos; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
982 |
end; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
983 |
inc(pos); |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
984 |
end; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
985 |
end |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
986 |
else numLines := 1; |
2017 | 987 |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
988 |
textWidth:=((w-(cornerWidth-edgeWidth)*2) div edgeWidth)*edgeWidth+edgeWidth; |
2022 | 989 |
textHeight:=(((numlines * h + 2)-((cornerHeight-edgeWidth)*2)) div edgeWidth)*edgeWidth; |
2019 | 990 |
|
2022 | 991 |
textHeight:=max(textHeight,edgeWidth); |
2017 | 992 |
//textWidth:=max(textWidth,SpritesData[tail].Width); |
993 |
rect.x:= 0; |
|
994 |
rect.y:= 0; |
|
2022 | 995 |
rect.w:= textWidth + (cornerWidth * 2); |
996 |
rect.h:= textHeight + cornerHeight*2 - edgeHeight + SpritesData[tail].Height; |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
997 |
//s:= inttostr(w) + ' ' + inttostr(numlines) + ' ' + inttostr(rect.x) + ' '+inttostr(rect.y) + ' ' + inttostr(rect.w) + ' ' + inttostr(rect.h); |
2017 | 998 |
|
2695 | 999 |
finalSurface:= SDL_CreateRGBSurface(SDL_SWSURFACE, rect.w, rect.h, 32, RMask, GMask, BMask, AMask); |
2017 | 1000 |
|
2695 | 1001 |
TryDo(finalSurface <> nil, 'RenderString: fail to create surface', true); |
2017 | 1002 |
|
1003 |
//////////////////////////////// CORNERS /////////////////////////////// |
|
2695 | 1004 |
copyToXY(SpritesData[corner].Surface, finalSurface, 0, 0); /////////////////// NW |
2017 | 1005 |
|
1006 |
flipSurface(SpritesData[corner].Surface, true); // store all 4 versions in memory to avoid repeated flips? |
|
1007 |
x:= 0; |
|
1008 |
y:= textHeight + cornerHeight -1; |
|
2695 | 1009 |
copyToXY(SpritesData[corner].Surface, finalSurface, x, y); /////////////////// SW |
2017 | 1010 |
|
1011 |
flipSurface(SpritesData[corner].Surface, false); |
|
1012 |
x:= rect.w-cornerWidth-1; |
|
1013 |
y:= textHeight + cornerHeight -1; |
|
2695 | 1014 |
copyToXY(SpritesData[corner].Surface, finalSurface, x, y); /////////////////// SE |
2017 | 1015 |
|
1016 |
flipSurface(SpritesData[corner].Surface, true); |
|
1017 |
x:= rect.w-cornerWidth-1; |
|
1018 |
y:= 0; |
|
2695 | 1019 |
copyToXY(SpritesData[corner].Surface, finalSurface, x, y); /////////////////// NE |
2017 | 1020 |
flipSurface(SpritesData[corner].Surface, false); // restore original position |
1021 |
//////////////////////////////// END CORNERS /////////////////////////////// |
|
1022 |
||
1023 |
//////////////////////////////// EDGES ////////////////////////////////////// |
|
1024 |
x:= cornerWidth; |
|
1025 |
y:= 0; |
|
1026 |
while x < rect.w-cornerWidth-1 do |
|
1027 |
begin |
|
2695 | 1028 |
copyToXY(SpritesData[edge].Surface, finalSurface, x, y); ///////////////// top edge |
2017 | 1029 |
inc(x,edgeWidth); |
1030 |
end; |
|
1031 |
flipSurface(SpritesData[edge].Surface, true); |
|
1032 |
x:= cornerWidth; |
|
1033 |
y:= textHeight + cornerHeight*2 - edgeHeight-1; |
|
1034 |
while x < rect.w-cornerWidth-1 do |
|
1035 |
begin |
|
2695 | 1036 |
copyToXY(SpritesData[edge].Surface, finalSurface, x, y); ///////////////// bottom edge |
2017 | 1037 |
inc(x,edgeWidth); |
1038 |
end; |
|
1039 |
flipSurface(SpritesData[edge].Surface, true); // restore original position |
|
1040 |
||
1041 |
rotatedEdge:= SDL_CreateRGBSurface(SDL_SWSURFACE, edgeHeight, edgeWidth, 32, RMask, GMask, BMask, AMask); |
|
1042 |
x:= rect.w - edgeHeight - 1; |
|
1043 |
y:= cornerHeight; |
|
1044 |
//// initially was going to rotate in place, but the SDL spec claims width/height are read only |
|
1045 |
copyRotatedSurface(SpritesData[edge].Surface,rotatedEdge); |
|
1046 |
while y < textHeight + cornerHeight do |
|
1047 |
begin |
|
2695 | 1048 |
copyToXY(rotatedEdge, finalSurface, x, y); |
2017 | 1049 |
inc(y,edgeWidth); |
1050 |
end; |
|
1051 |
flipSurface(rotatedEdge, false); // restore original position |
|
1052 |
x:= 0; |
|
1053 |
y:= cornerHeight; |
|
1054 |
while y < textHeight + cornerHeight do |
|
1055 |
begin |
|
2695 | 1056 |
copyToXY(rotatedEdge, finalSurface, x, y); |
2017 | 1057 |
inc(y,edgeWidth); |
1058 |
end; |
|
1059 |
//////////////////////////////// END EDGES ////////////////////////////////////// |
|
1060 |
||
1061 |
x:= cornerWidth; |
|
1062 |
y:= textHeight + cornerHeight * 2 - edgeHeight - 1; |
|
2695 | 1063 |
copyToXY(SpritesData[tail].Surface, finalSurface, x, y); |
2017 | 1064 |
|
1065 |
rect.x:= edgeHeight; |
|
1066 |
rect.y:= edgeHeight; |
|
1067 |
rect.w:= rect.w - edgeHeight * 2; |
|
1068 |
rect.h:= textHeight + cornerHeight * 2 - edgeHeight * 2; |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
1069 |
i:= rect.w; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
1070 |
j:= rect.h; |
2695 | 1071 |
SDL_FillRect(finalSurface, @rect, cWhiteColor); |
2017 | 1072 |
|
1073 |
pos:= 1; prevpos:= 0; line:= 0; |
|
1074 |
while pos <= length(s) do |
|
1075 |
begin |
|
1076 |
if (s[pos] = #1) or (pos = length(s)) then |
|
1077 |
begin |
|
1078 |
if s[pos] <> #1 then inc(pos); |
|
1079 |
while s[prevpos+1] = ' 'do inc(prevpos); |
|
1080 |
substr:= copy(s, prevpos+1, pos-prevpos-1); |
|
1081 |
if Length(substr) <> 0 then |
|
1082 |
begin |
|
2666 | 1083 |
tmpsurf:= TTF_RenderUTF8_Blended(Fontz[Font].Handle, Str2PChar(substr), cNearBlackColorChannels); |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
1084 |
rect.x:= edgeHeight + 1 + ((i - w) div 2); |
2022 | 1085 |
// trying to more evenly position the text, vertically |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2022
diff
changeset
|
1086 |
rect.y:= edgeHeight + ((j-(numLines*h)) div 2) + line * h; |
2017 | 1087 |
SDLTry(tmpsurf <> nil, true); |
2695 | 1088 |
SDL_UpperBlit(tmpsurf, nil, finalSurface, @rect); |
2017 | 1089 |
SDL_FreeSurface(tmpsurf); |
1090 |
inc(line); |
|
1091 |
prevpos:= pos; |
|
1092 |
end; |
|
1093 |
end; |
|
1094 |
inc(pos); |
|
1095 |
end; |
|
1096 |
||
2695 | 1097 |
//TryDo(SDL_SetColorKey(finalSurface, SDL_SRCCOLORKEY, 0) = 0, errmsgTransparentSet, true); |
1098 |
RenderSpeechBubbleTex:= Surface2Tex(finalSurface, true); |
|
2017 | 1099 |
|
1100 |
SDL_FreeSurface(rotatedEdge); |
|
2695 | 1101 |
SDL_FreeSurface(finalSurface); |
2017 | 1102 |
end; |
1103 |
||
4 | 1104 |
procedure RenderHealth(var Hedgehog: THedgehog); |
95 | 1105 |
var s: shortstring; |
4 | 1106 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1107 |
str(Hedgehog.Gear^.Health, s); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1108 |
if Hedgehog.HealthTagTex <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1109 |
FreeTexture(Hedgehog.HealthTagTex); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1110 |
Hedgehog.HealthTagTex:= RenderStringTex(s, Hedgehog.Team^.Clan^.Color, fnt16) |
4 | 1111 |
end; |
1112 |
||
2905 | 1113 |
function LoadImage(const filename: shortstring; imageFlags: LongInt): PSDL_Surface; |
30 | 1114 |
var tmpsurf: PSDL_Surface; |
355 | 1115 |
s: shortstring; |
4 | 1116 |
begin |
3906 | 1117 |
WriteToConsole(msgLoading + filename + '.png [flags: ' + inttostr(imageFlags) + ']'); |
2426 | 1118 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1119 |
s:= filename + '.png'; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1120 |
tmpsurf:= IMG_Load(Str2PChar(s)); |
2254 | 1121 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1122 |
if tmpsurf = nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1123 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1124 |
OutError(msgFailed, (imageFlags and ifCritical) <> 0); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1125 |
exit(nil) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1126 |
end; |
2153 | 1127 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1128 |
if ((imageFlags and ifIgnoreCaps) = 0) and ((tmpsurf^.w > MaxTextureSize) or (tmpsurf^.h > MaxTextureSize)) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1129 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1130 |
SDL_FreeSurface(tmpsurf); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1131 |
OutError(msgFailedSize, (imageFlags and ifCritical) <> 0); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1132 |
// dummy surface to replace non-critical textures that failed to load due to their size |
3862 | 1133 |
exit(SDL_CreateRGBSurface(SDL_SWSURFACE, 2, 2, 32, RMask, GMask, BMask, AMask)); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1134 |
end; |
351 | 1135 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1136 |
tmpsurf:= doSurfaceConversion(tmpsurf); |
2630 | 1137 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1138 |
if (imageFlags and ifTransparent) <> 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1139 |
TryDo(SDL_SetColorKey(tmpsurf, SDL_SRCCOLORKEY, 0) = 0, errmsgTransparentSet, true); |
2630 | 1140 |
|
3407 | 1141 |
WriteLnToConsole(msgOK + ' (' + inttostr(tmpsurf^.w) + 'x' + inttostr(tmpsurf^.h) + ')'); |
2630 | 1142 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1143 |
LoadImage:= tmpsurf //Result |
753 | 1144 |
end; |
1145 |
||
2905 | 1146 |
function glLoadExtension(extension : shortstring) : boolean; |
2428 | 1147 |
begin |
2580
aeccc8f51d3f
completes touch input/control (problems with moving camera)
koda
parents:
2578
diff
changeset
|
1148 |
{$IFDEF IPHONEOS} |
3971 | 1149 |
extension:= extension; // avoid hint |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1150 |
glLoadExtension:= false; |
3333 | 1151 |
{$IFDEF DEBUGFILE} |
1152 |
AddFileLog('OpenGL - "' + extension + '" skipped') |
|
1153 |
{$ENDIF} |
|
2580
aeccc8f51d3f
completes touch input/control (problems with moving camera)
koda
parents:
2578
diff
changeset
|
1154 |
{$ELSE} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1155 |
glLoadExtension:= glext_LoadExtension(extension); |
2568
e654cbfb23ba
Bunch of neat stuff by Smaxx. ATI check, translucent name tags to reduce terrain fail, disabling health crates on invulnerable hogs. Also tweaks to prior stuff.
nemo
parents:
2567
diff
changeset
|
1156 |
{$IFDEF DEBUGFILE} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1157 |
if not glLoadExtension then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1158 |
AddFileLog('OpenGL - "' + extension + '" failed to load') |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1159 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1160 |
AddFileLog('OpenGL - "' + extension + '" loaded'); |
2568
e654cbfb23ba
Bunch of neat stuff by Smaxx. ATI check, translucent name tags to reduce terrain fail, disabling health crates on invulnerable hogs. Also tweaks to prior stuff.
nemo
parents:
2567
diff
changeset
|
1161 |
{$ENDIF} |
3333 | 1162 |
{$ENDIF} |
2428 | 1163 |
end; |
1164 |
||
753 | 1165 |
procedure SetupOpenGL; |
3928
2560731c860d
move all mobile-related functions in their own module, provides a structure for future mobile ports
koda
parents:
3922
diff
changeset
|
1166 |
{$IFNDEF IPHONEOS} |
2568
e654cbfb23ba
Bunch of neat stuff by Smaxx. ATI check, translucent name tags to reduce terrain fail, disabling health crates on invulnerable hogs. Also tweaks to prior stuff.
nemo
parents:
2567
diff
changeset
|
1167 |
var vendor: shortstring; |
3405 | 1168 |
{$IFDEF DARWIN} |
1169 |
one: LongInt; |
|
1170 |
{$ENDIF} |
|
3928
2560731c860d
move all mobile-related functions in their own module, provides a structure for future mobile ports
koda
parents:
3922
diff
changeset
|
1171 |
{$ENDIF} |
753 | 1172 |
begin |
3405 | 1173 |
|
2697 | 1174 |
{$IFDEF IPHONEOS} |
3376 | 1175 |
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0); // no double buffering |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1176 |
SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, 1); |
3376 | 1177 |
{$ELSE} |
1178 |
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); |
|
3928
2560731c860d
move all mobile-related functions in their own module, provides a structure for future mobile ports
koda
parents:
3922
diff
changeset
|
1179 |
vendor:= LowerCase(shortstring(pchar(glGetString(GL_VENDOR)))); |
3405 | 1180 |
{$IFNDEF SDL13} |
1181 |
// this attribute is default in 1.3 and must be enabled in MacOSX |
|
3670
4c673e57f0d7
use llvm to compile, don't preview map on wimpier devices, merge vsync, fix iphone launch image
koda
parents:
3663
diff
changeset
|
1182 |
if (cReducedQuality and rqDesyncVBlank) <> 0 then |
4c673e57f0d7
use llvm to compile, don't preview map on wimpier devices, merge vsync, fix iphone launch image
koda
parents:
3663
diff
changeset
|
1183 |
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 0) |
4c673e57f0d7
use llvm to compile, don't preview map on wimpier devices, merge vsync, fix iphone launch image
koda
parents:
3663
diff
changeset
|
1184 |
else |
3405 | 1185 |
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1); |
1186 |
{$IFDEF DARWIN} |
|
1187 |
// fixes vsync in Snow Leopard |
|
3670
4c673e57f0d7
use llvm to compile, don't preview map on wimpier devices, merge vsync, fix iphone launch image
koda
parents:
3663
diff
changeset
|
1188 |
one:= 1; |
3405 | 1189 |
CGLSetParameter(CGLGetCurrentContext(), 222, @one); |
1190 |
{$ENDIF} |
|
1191 |
{$ENDIF} |
|
3376 | 1192 |
{$ENDIF} |
1193 |
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0); // no depth buffer |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1194 |
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1195 |
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1196 |
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5); |
3376 | 1197 |
SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0); // no alpha channel required |
1198 |
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 16); // buffer has to be 16 bit only |
|
1199 |
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1); // try to prefer hardware rendering |
|
2697 | 1200 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1201 |
glGetIntegerv(GL_MAX_TEXTURE_SIZE, @MaxTextureSize); |
2697 | 1202 |
|
1203 |
{$IFDEF DEBUGFILE} |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1204 |
AddFileLog('OpenGL-- Renderer: ' + shortstring(pchar(glGetString(GL_RENDERER)))); |
3757 | 1205 |
AddFileLog(' |----- Vendor: ' + shortstring(pchar(glGetString(GL_VENDOR)))); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1206 |
AddFileLog(' |----- Version: ' + shortstring(pchar(glGetString(GL_VERSION)))); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1207 |
AddFileLog(' \----- GL_MAX_TEXTURE_SIZE: ' + inttostr(MaxTextureSize)); |
2153 | 1208 |
{$ENDIF} |
2252 | 1209 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1210 |
if MaxTextureSize <= 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1211 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1212 |
MaxTextureSize:= 1024; |
2568
e654cbfb23ba
Bunch of neat stuff by Smaxx. ATI check, translucent name tags to reduce terrain fail, disabling health crates on invulnerable hogs. Also tweaks to prior stuff.
nemo
parents:
2567
diff
changeset
|
1213 |
{$IFDEF DEBUGFILE} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1214 |
AddFileLog('OpenGL Warning - driver didn''t provide any valid max texture size; assuming 1024'); |
2568
e654cbfb23ba
Bunch of neat stuff by Smaxx. ATI check, translucent name tags to reduce terrain fail, disabling health crates on invulnerable hogs. Also tweaks to prior stuff.
nemo
parents:
2567
diff
changeset
|
1215 |
{$ENDIF} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1216 |
end; |
2568
e654cbfb23ba
Bunch of neat stuff by Smaxx. ATI check, translucent name tags to reduce terrain fail, disabling health crates on invulnerable hogs. Also tweaks to prior stuff.
nemo
parents:
2567
diff
changeset
|
1217 |
|
3695
c11abf387a7d
reverted stereo craziness - the experimental3D branch has been created for a reason
koda
parents:
3691
diff
changeset
|
1218 |
{$IFNDEF IPHONEOS} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1219 |
if StrPos(Str2PChar(vendor), Str2PChar('nvidia')) <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1220 |
cGPUVendor:= gvNVIDIA |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1221 |
else if StrPos(Str2PChar(vendor), Str2PChar('intel')) <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1222 |
cGPUVendor:= gvATI |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1223 |
else if StrPos(Str2PChar(vendor), Str2PChar('ati')) <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1224 |
cGPUVendor:= gvIntel; |
2647 | 1225 |
//SupportNPOTT:= glLoadExtension('GL_ARB_texture_non_power_of_two'); |
3695
c11abf387a7d
reverted stereo craziness - the experimental3D branch has been created for a reason
koda
parents:
3691
diff
changeset
|
1226 |
{$ELSE} |
c11abf387a7d
reverted stereo craziness - the experimental3D branch has been created for a reason
koda
parents:
3691
diff
changeset
|
1227 |
cGPUVendor:= gvApple; |
2735 | 1228 |
{$ENDIF} |
1229 |
||
1230 |
{$IFDEF DEBUGFILE} |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1231 |
if cGPUVendor = gvUnknown then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1232 |
AddFileLog('OpenGL Warning - unknown hardware vendor; please report'); |
2735 | 1233 |
{$ELSE} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1234 |
// just avoid 'never used' compiler warning for now |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1235 |
if cGPUVendor = gvUnknown then cGPUVendor:= gvUnknown; |
2428 | 1236 |
{$ENDIF} |
1237 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1238 |
// set view port to whole window |
3940
cc29628976cc
some optimizations to drawing and fetching data of new ammomenu
koda
parents:
3939
diff
changeset
|
1239 |
if (rotationQt = 0) or (rotationQt = 180) then |
3922
44804043b691
iPad Video Out support (+less warnings +code update for latest SDL)
koda
parents:
3906
diff
changeset
|
1240 |
glViewport(0, 0, cScreenWidth, cScreenHeight) |
44804043b691
iPad Video Out support (+less warnings +code update for latest SDL)
koda
parents:
3906
diff
changeset
|
1241 |
else |
44804043b691
iPad Video Out support (+less warnings +code update for latest SDL)
koda
parents:
3906
diff
changeset
|
1242 |
glViewport(0, 0, cScreenHeight, cScreenWidth); |
2428 | 1243 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1244 |
glMatrixMode(GL_MODELVIEW); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1245 |
// prepare default translation/scaling |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1246 |
glLoadIdentity(); |
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1247 |
glRotatef(rotationQt, 0, 0, 1); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1248 |
glScalef(2.0 / cScreenWidth, -2.0 / cScreenHeight, 1.0); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1249 |
glTranslatef(0, -cScreenHeight / 2, 0); |
2428 | 1250 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1251 |
// enable alpha blending |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1252 |
glEnable(GL_BLEND); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1253 |
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
3376 | 1254 |
// disable/lower perspective correction (won't need it anyway) |
1255 |
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); |
|
1256 |
// disable dithering |
|
1257 |
glDisable(GL_DITHER); |
|
3641 | 1258 |
// enable common states by default as they save a lot |
3376 | 1259 |
glEnable(GL_TEXTURE_2D); |
3697 | 1260 |
glEnableClientState(GL_VERTEX_ARRAY); |
1261 |
glEnableClientState(GL_TEXTURE_COORD_ARRAY); |
|
4 | 1262 |
end; |
1263 |
||
2161
0c8634241fa4
Some work on zooming. Hedgewars are now unplayable.
unc0rr
parents:
2154
diff
changeset
|
1264 |
procedure SetScale(f: GLfloat); |
0c8634241fa4
Some work on zooming. Hedgewars are now unplayable.
unc0rr
parents:
2154
diff
changeset
|
1265 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1266 |
// leave immediately if scale factor did not change |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1267 |
if f = cScaleFactor then exit; |
2161
0c8634241fa4
Some work on zooming. Hedgewars are now unplayable.
unc0rr
parents:
2154
diff
changeset
|
1268 |
|
3523 | 1269 |
if f = cDefaultZoomLevel then |
1270 |
glPopMatrix // "return" to default scaling |
|
1271 |
else // other scaling |
|
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1272 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1273 |
glPushMatrix; // save default scaling |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1274 |
glLoadIdentity; |
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1275 |
glRotatef(rotationQt, 0, 0, 1); |
3922
44804043b691
iPad Video Out support (+less warnings +code update for latest SDL)
koda
parents:
3906
diff
changeset
|
1276 |
glScalef(f / cScreenWidth, -f / cScreenHeight, 1.0); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1277 |
glTranslatef(0, -cScreenHeight / 2, 0); |
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1278 |
end; |
2258 | 1279 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1280 |
cScaleFactor:= f; |
2161
0c8634241fa4
Some work on zooming. Hedgewars are now unplayable.
unc0rr
parents:
2154
diff
changeset
|
1281 |
end; |
0c8634241fa4
Some work on zooming. Hedgewars are now unplayable.
unc0rr
parents:
2154
diff
changeset
|
1282 |
|
510 | 1283 |
//////////////////////////////////////////////////////////////////////////////// |
1284 |
procedure AddProgress; |
|
1285 |
var r: TSDL_Rect; |
|
766 | 1286 |
texsurf: PSDL_Surface; |
510 | 1287 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1288 |
if Step = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1289 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1290 |
WriteToConsole(msgLoading + 'progress sprite: '); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1291 |
texsurf:= LoadImage(Pathz[ptGraphics] + '/Progress', ifCritical or ifTransparent); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1292 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1293 |
ProgrTex:= Surface2Tex(texsurf, false); |
3697 | 1294 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1295 |
squaresize:= texsurf^.w shr 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1296 |
numsquares:= texsurf^.h div squaresize; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1297 |
SDL_FreeSurface(texsurf); |
3928
2560731c860d
move all mobile-related functions in their own module, provides a structure for future mobile ports
koda
parents:
3922
diff
changeset
|
1298 |
|
3935 | 1299 |
perfExt_AddProgress(); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1300 |
end; |
1045 | 1301 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1302 |
TryDo(ProgrTex <> nil, 'Error - Progress Texure is nil!', true); |
2284 | 1303 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1304 |
glClear(GL_COLOR_BUFFER_BIT); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1305 |
if Step < numsquares then r.x:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1306 |
else r.x:= squaresize; |
3697 | 1307 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1308 |
r.y:= (Step mod numsquares) * squaresize; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1309 |
r.w:= squaresize; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1310 |
r.h:= squaresize; |
3697 | 1311 |
|
3922
44804043b691
iPad Video Out support (+less warnings +code update for latest SDL)
koda
parents:
3906
diff
changeset
|
1312 |
DrawFromRect( -squaresize div 2, (cScreenHeight - squaresize) shr 1, @r, ProgrTex); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1313 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1314 |
SDL_GL_SwapBuffers(); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1315 |
{$IFDEF SDL13} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1316 |
SDL_RenderPresent(); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1317 |
{$ENDIF} |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1318 |
inc(Step); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1319 |
|
510 | 1320 |
end; |
1321 |
||
1322 |
procedure FinishProgress; |
|
1323 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1324 |
WriteLnToConsole('Freeing progress surface... '); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1325 |
FreeTexture(ProgrTex); |
3935 | 1326 |
perfExt_FinishProgress(); |
510 | 1327 |
end; |
1328 |
||
2017 | 1329 |
procedure flipSurface(Surface: PSDL_Surface; Vertical: Boolean); |
1330 |
var y, x, i, j: LongInt; |
|
1331 |
tmpPixel: Longword; |
|
1332 |
pixels: PLongWordArray; |
|
1333 |
begin |
|
1334 |
TryDo(Surface^.format^.BytesPerPixel = 4, 'flipSurface failed, expecting 32 bit surface', true); |
|
1335 |
pixels:= Surface^.pixels; |
|
1336 |
if Vertical then |
|
1337 |
for y := 0 to (Surface^.h div 2) - 1 do |
|
1338 |
for x := 0 to Surface^.w - 1 do |
|
1339 |
begin |
|
1340 |
i:= y * Surface^.w + x; |
|
1341 |
j:= (Surface^.h - y - 1) * Surface^.w + x; |
|
1342 |
tmpPixel:= pixels^[i]; |
|
1343 |
pixels^[i]:= pixels^[j]; |
|
1344 |
pixels^[j]:= tmpPixel; |
|
1345 |
end |
|
1346 |
else |
|
1347 |
for x := 0 to (Surface^.w div 2) - 1 do |
|
1348 |
for y := 0 to Surface^.h -1 do |
|
1349 |
begin |
|
1350 |
i:= y*Surface^.w + x; |
|
1351 |
j:= y*Surface^.w + (Surface^.w - x - 1); |
|
1352 |
tmpPixel:= pixels^[i]; |
|
1353 |
pixels^[i]:= pixels^[j]; |
|
1354 |
pixels^[j]:= tmpPixel; |
|
1355 |
end; |
|
1356 |
end; |
|
1357 |
||
3169
c8c6ac44f51b
prophylactic removal of some Integer references, raise a few of the template islands up a bit so they work inverted without triggering border
nemo
parents:
3165
diff
changeset
|
1358 |
procedure copyToXY(src, dest: PSDL_Surface; destX, destY: LongInt); |
2017 | 1359 |
var srcX, srcY, i, j, maxDest: LongInt; |
1360 |
srcPixels, destPixels: PLongWordArray; |
|
3341 | 1361 |
r0, g0, b0, a0, r1, g1, b1, a1: Byte; |
2017 | 1362 |
begin |
1363 |
maxDest:= (dest^.pitch div 4) * dest^.h; |
|
1364 |
srcPixels:= src^.pixels; |
|
1365 |
destPixels:= dest^.pixels; |
|
1366 |
||
1367 |
for srcX:= 0 to src^.w - 1 do |
|
1368 |
for srcY:= 0 to src^.h - 1 do |
|
1369 |
begin |
|
1370 |
i:= (destY + srcY) * (dest^.pitch div 4) + destX + srcX; |
|
1371 |
j:= srcY * (src^.pitch div 4) + srcX; |
|
3341 | 1372 |
if (i < maxDest) and (srcPixels^[j] and AMask <> 0) then |
1373 |
begin |
|
1374 |
SDL_GetRGBA(destPixels^[i], dest^.format, @r0, @g0, @b0, @a0); |
|
1375 |
SDL_GetRGBA(srcPixels^[j], src^.format, @r1, @g1, @b1, @a1); |
|
3407 | 1376 |
r0:= (r0 * (255 - LongInt(a1)) + r1 * LongInt(a1)) div 255; |
1377 |
g0:= (g0 * (255 - LongInt(a1)) + g1 * LongInt(a1)) div 255; |
|
1378 |
b0:= (b0 * (255 - LongInt(a1)) + b1 * LongInt(a1)) div 255; |
|
1379 |
a0:= (a0 * (255 - LongInt(a1)) + a1 * LongInt(a1)) div 255; |
|
1380 |
destPixels^[i]:= SDL_MapRGBA(dest^.format, r0, g0, b0, a0); |
|
3341 | 1381 |
end; |
2017 | 1382 |
end; |
1383 |
end; |
|
1384 |
||
1385 |
procedure copyRotatedSurface(src, dest: PSDL_Surface); // this is necessary since width/height are read only in SDL, apparently |
|
1386 |
var y, x, i, j: LongInt; |
|
1387 |
srcPixels, destPixels: PLongWordArray; |
|
1388 |
begin |
|
1389 |
TryDo(src^.format^.BytesPerPixel = 4, 'rotateSurface failed, expecting 32 bit surface', true); |
|
1390 |
TryDo(dest^.format^.BytesPerPixel = 4, 'rotateSurface failed, expecting 32 bit surface', true); |
|
1391 |
||
1392 |
srcPixels:= src^.pixels; |
|
1393 |
destPixels:= dest^.pixels; |
|
1394 |
||
1395 |
j:= 0; |
|
1396 |
for x := 0 to src^.w - 1 do |
|
1397 |
for y := 0 to src^.h - 1 do |
|
1398 |
begin |
|
1399 |
i:= (src^.h - 1 - y) * (src^.pitch div 4) + x; |
|
1400 |
destPixels^[j]:= srcPixels^[i]; |
|
1401 |
inc(j) |
|
1402 |
end; |
|
1403 |
end; |
|
1404 |
||
2905 | 1405 |
function RenderHelpWindow(caption, subcaption, description, extra: ansistring; extracolor: LongInt; iconsurf: PSDL_Surface; iconrect: PSDL_Rect): PTexture; |
2747 | 1406 |
var tmpsurf: PSDL_SURFACE; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1407 |
w, h, i, j: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1408 |
font: THWFont; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1409 |
r, r2: TSDL_Rect; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1410 |
wa, ha: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1411 |
tmpline, tmpline2, tmpdesc: ansistring; |
2747 | 1412 |
begin |
2843 | 1413 |
// make sure there is a caption as well as a sub caption - description is optional |
1414 |
if caption = '' then caption:= '???'; |
|
1415 |
if subcaption = '' then subcaption:= ' '; |
|
1416 |
||
2841 | 1417 |
font:= CheckCJKFont(caption,fnt16); |
1418 |
font:= CheckCJKFont(subcaption,font); |
|
1419 |
font:= CheckCJKFont(description,font); |
|
1420 |
font:= CheckCJKFont(extra,font); |
|
2747 | 1421 |
|
1422 |
w:= 0; |
|
1423 |
h:= 0; |
|
1424 |
wa:= FontBorder * 2 + 4; |
|
1425 |
ha:= FontBorder * 2; |
|
1426 |
||
3407 | 1427 |
i:= 0; j:= 0; // avoid compiler hints |
1428 |
||
2747 | 1429 |
// TODO: Recheck height/position calculation |
1430 |
||
1431 |
// get caption's dimensions |
|
1432 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(caption), i, j); |
|
1433 |
// width adds 36 px (image + space) |
|
1434 |
w:= i + 36 + wa; |
|
1435 |
h:= j + ha; |
|
1436 |
||
1437 |
// get sub caption's dimensions |
|
1438 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(subcaption), i, j); |
|
1439 |
// width adds 36 px (image + space) |
|
1440 |
if w < (i + 36 + wa) then w:= i + 36 + wa; |
|
1441 |
inc(h, j + ha); |
|
1442 |
||
1443 |
// get description's dimensions |
|
1444 |
tmpdesc:= description; |
|
1445 |
while tmpdesc <> '' do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1446 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1447 |
tmpline:= tmpdesc; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1448 |
SplitByChar(tmpline, tmpdesc, '|'); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1449 |
if tmpline <> '' then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1450 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1451 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(tmpline), i, j); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1452 |
if w < (i + wa) then w:= i + wa; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1453 |
inc(h, j + ha) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1454 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1455 |
end; |
2747 | 1456 |
|
1457 |
if extra <> '' then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1458 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1459 |
// get extra label's dimensions |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1460 |
TTF_SizeUTF8(Fontz[font].Handle, Str2PChar(extra), i, j); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1461 |
if w < (i + wa) then w:= i + wa; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1462 |
inc(h, j + ha); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1463 |
end; |
3697 | 1464 |
|
2747 | 1465 |
// add borders space |
1466 |
inc(w, wa); |
|
1467 |
inc(h, ha + 8); |
|
1468 |
||
1469 |
tmpsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, RMask, GMask, BMask, AMask); |
|
1470 |
TryDo(tmpsurf <> nil, 'RenderHelpWindow: fail to create surface', true); |
|
1471 |
||
1472 |
// render border and background |
|
1473 |
r.x:= 0; |
|
1474 |
r.y:= 0; |
|
1475 |
r.w:= w; |
|
1476 |
r.h:= h; |
|
1477 |
DrawRoundRect(@r, cWhiteColor, cNearBlackColor, tmpsurf, true); |
|
1478 |
||
1479 |
// render caption |
|
1480 |
r:= WriteInRect(tmpsurf, 36 + FontBorder + 2, ha, $ffffffff, font, caption); |
|
1481 |
// render sub caption |
|
1482 |
r:= WriteInRect(tmpsurf, 36 + FontBorder + 2, r.y + r.h, $ffc7c7c7, font, subcaption); |
|
1483 |
||
1484 |
// render all description lines |
|
1485 |
tmpdesc:= description; |
|
1486 |
while tmpdesc <> '' do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1487 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1488 |
tmpline:= tmpdesc; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1489 |
SplitByChar(tmpline, tmpdesc, '|'); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1490 |
r2:= r; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1491 |
if tmpline <> '' then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1492 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1493 |
r:= WriteInRect(tmpsurf, FontBorder + 2, r.y + r.h, $ff707070, font, tmpline); |
3697 | 1494 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1495 |
// render highlighted caption (if there's a ':') |
3407 | 1496 |
tmpline2:= ''; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1497 |
SplitByChar(tmpline, tmpline2, ':'); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1498 |
if tmpline2 <> '' then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1499 |
WriteInRect(tmpsurf, FontBorder + 2, r2.y + r2.h, $ffc7c7c7, font, tmpline + ':'); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1500 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1501 |
end; |
2747 | 1502 |
|
1503 |
if extra <> '' then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1504 |
r:= WriteInRect(tmpsurf, FontBorder + 2, r.y + r.h, extracolor, font, extra); |
2747 | 1505 |
|
1506 |
r.x:= FontBorder + 6; |
|
1507 |
r.y:= FontBorder + 4; |
|
1508 |
r.w:= 32; |
|
1509 |
r.h:= 32; |
|
1510 |
SDL_FillRect(tmpsurf, @r, $ffffffff); |
|
1511 |
SDL_UpperBlit(iconsurf, iconrect, tmpsurf, @r); |
|
3697 | 1512 |
|
2747 | 1513 |
RenderHelpWindow:= Surface2Tex(tmpsurf, true); |
1514 |
SDL_FreeSurface(tmpsurf) |
|
1515 |
end; |
|
1516 |
||
1517 |
procedure RenderWeaponTooltip(atype: TAmmoType); |
|
1518 |
var r: TSDL_Rect; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1519 |
i: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1520 |
extra: ansistring; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1521 |
extracolor: LongInt; |
2747 | 1522 |
begin |
3634 | 1523 |
// don't do anything if the window shouldn't be shown |
1524 |
if (cReducedQuality and rqTooltipsOff) <> 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1525 |
begin |
3634 | 1526 |
WeaponTooltipTex:= nil; |
1527 |
exit |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1528 |
end; |
2747 | 1529 |
|
1530 |
// free old texture |
|
1531 |
FreeWeaponTooltip; |
|
1532 |
||
1533 |
// image region |
|
1534 |
i:= LongInt(atype) - 1; |
|
3853 | 1535 |
r.x:= (i shr 4) * 32; |
1536 |
r.y:= (i mod 16) * 32; |
|
2747 | 1537 |
r.w:= 32; |
1538 |
r.h:= 32; |
|
1539 |
||
1540 |
// default (no extra text) |
|
1541 |
extra:= ''; |
|
1542 |
extracolor:= 0; |
|
1543 |
||
1544 |
if (CurrentTeam <> nil) and (Ammoz[atype].SkipTurns >= CurrentTeam^.Clan^.TurnNumber) then // weapon or utility is not yet available |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1545 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1546 |
extra:= trmsg[sidNotYetAvailable]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1547 |
extracolor:= LongInt($ffc77070); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1548 |
end |
2747 | 1549 |
else if (Ammoz[atype].Ammo.Propz and ammoprop_NoRoundEndHint) <> 0 then // weapon or utility won't end your turn |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1550 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1551 |
extra:= trmsg[sidNoEndTurn]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1552 |
extracolor:= LongInt($ff70c770); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1553 |
end |
3697 | 1554 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1555 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1556 |
extra:= ''; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1557 |
extracolor:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1558 |
end; |
2747 | 1559 |
|
1560 |
// render window and return the texture |
|
1561 |
WeaponTooltipTex:= RenderHelpWindow(trammo[Ammoz[atype].NameId], trammoc[Ammoz[atype].NameId], trammod[Ammoz[atype].NameId], extra, extracolor, SpritesData[sprAMAmmos].Surface, @r) |
|
2753 | 1562 |
end; |
2747 | 1563 |
|
1564 |
procedure ShowWeaponTooltip(x, y: LongInt); |
|
1565 |
begin |
|
1566 |
// draw the texture if it exists |
|
1567 |
if WeaponTooltipTex <> nil then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1568 |
DrawTexture(x, y, WeaponTooltipTex) |
2747 | 1569 |
end; |
1570 |
||
1571 |
procedure FreeWeaponTooltip; |
|
1572 |
begin |
|
1573 |
// free the existing texture (if there's any) |
|
1574 |
if WeaponTooltipTex = nil then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2910
diff
changeset
|
1575 |
exit; |
2747 | 1576 |
FreeTexture(WeaponTooltipTex); |
1577 |
WeaponTooltipTex:= nil |
|
1578 |
end; |
|
1579 |
||
3038 | 1580 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
1581 |
begin |
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1582 |
PixelFormat:= nil; |
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1583 |
SDLPrimSurface:= nil; |
3922
44804043b691
iPad Video Out support (+less warnings +code update for latest SDL)
koda
parents:
3906
diff
changeset
|
1584 |
|
44804043b691
iPad Video Out support (+less warnings +code update for latest SDL)
koda
parents:
3906
diff
changeset
|
1585 |
{$IFNDEF IPHONEOS} |
3626 | 1586 |
rotationQt:= 0; |
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1587 |
cGPUVendor:= gvUnknown; |
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1588 |
{$ENDIF} |
3697 | 1589 |
|
3394
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1590 |
cScaleFactor:= 2.0; |
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1591 |
SupportNPOTT:= false; |
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1592 |
Step:= 0; |
47b51e22e670
Henek's patch - adds a column to ammoMenu and removes the F* column in iphone version
koda
parents:
3390
diff
changeset
|
1593 |
ProgrTex:= nil; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
1594 |
end; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2698
diff
changeset
|
1595 |
|
3038 | 1596 |
procedure freeModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1597 |
begin |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1598 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2705
diff
changeset
|
1599 |
|
4 | 1600 |
end. |