author | nemo |
Thu, 17 May 2018 20:04:39 -0400 | |
changeset 13394 | 7b4726ef2308 |
parent 11532 | bf86c6cb9341 |
child 15929 | 128ace913837 |
permissions | -rw-r--r-- |
1806 | 1 |
(* |
2 |
* Hedgewars, a free turn based strategy game |
|
11046 | 3 |
* Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com> |
1806 | 4 |
* |
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 |
|
8 |
* |
|
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. |
|
13 |
* |
|
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 |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10040
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
1806 | 17 |
*) |
18 |
||
2599 | 19 |
{$INCLUDE "options.inc"} |
2587
0dfa56a8513c
fix a segfault in the iphone simulator by moving options.inc at the beginning of the file
koda
parents:
2376
diff
changeset
|
20 |
|
1806 | 21 |
unit uLandTexture; |
22 |
interface |
|
1807 | 23 |
uses SDLh; |
1806 | 24 |
|
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
25 |
procedure initModule; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
26 |
procedure freeModule; |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
27 |
procedure UpdateLandTexture(X, Width, Y, Height: LongInt; landAdded: boolean); |
1807 | 28 |
procedure DrawLand(dX, dY: LongInt); |
5654 | 29 |
procedure ResetLand; |
7850 | 30 |
procedure SetLandTexture; |
1806 | 31 |
|
32 |
implementation |
|
10267 | 33 |
uses uConsts, GLunit, uTypes, uVariables, uTextures, uDebug, uRender, uUtils; |
1807 | 34 |
|
7172
f68d62711a5c
After experimenting with a long running average at maxed out FPS and a variety of map sizes, 128 seems to actually be a good size to use if only drawing bits of world with stuff in it. 64 actually did even better in some situations, but significantly worse in others (lots of land, zoomed out).
nemo
parents:
7170
diff
changeset
|
35 |
const TEXSIZE = 128; |
10020
67e127027af6
small tweak/hax for blurry land to make tile borders vanish (when clamping is off)
sheepluva
parents:
9998
diff
changeset
|
36 |
// in avoid tile borders stretch the blurry texture by 1 pixel more |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10108
diff
changeset
|
37 |
BLURRYLANDOVERLAP: real = 1 / TEXSIZE / 2.0; // 1 pixel divided by texsize and blurry land scale factor |
1806 | 38 |
|
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
39 |
type TLandRecord = record |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
40 |
shouldUpdate, landAdded: boolean; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
41 |
tex: PTexture; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
42 |
end; |
3615 | 43 |
|
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
44 |
var LandTextures: array of array of TLandRecord; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
45 |
tmpPixels: array [0..TEXSIZE - 1, 0..TEXSIZE - 1] of LongWord; |
3615 | 46 |
LANDTEXARW: LongWord; |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
47 |
LANDTEXARH: LongWord; |
3697 | 48 |
|
1807 | 49 |
function Pixels(x, y: Longword): Pointer; |
50 |
var ty: Longword; |
|
1806 | 51 |
begin |
1807 | 52 |
for ty:= 0 to TEXSIZE - 1 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
53 |
Move(LandPixels[y * TEXSIZE + ty, x * TEXSIZE], tmpPixels[ty, 0], sizeof(Longword) * TEXSIZE); |
2376 | 54 |
|
1807 | 55 |
Pixels:= @tmpPixels |
56 |
end; |
|
1806 | 57 |
|
1859
e071284b118e
Pixels2 proc, which uses Land array when updating textures
unc0rr
parents:
1852
diff
changeset
|
58 |
function Pixels2(x, y: Longword): Pointer; |
e071284b118e
Pixels2 proc, which uses Land array when updating textures
unc0rr
parents:
1852
diff
changeset
|
59 |
var tx, ty: Longword; |
e071284b118e
Pixels2 proc, which uses Land array when updating textures
unc0rr
parents:
1852
diff
changeset
|
60 |
begin |
e071284b118e
Pixels2 proc, which uses Land array when updating textures
unc0rr
parents:
1852
diff
changeset
|
61 |
for ty:= 0 to TEXSIZE - 1 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
62 |
for tx:= 0 to TEXSIZE - 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
63 |
tmpPixels[ty, tx]:= Land[y * TEXSIZE + ty, x * TEXSIZE + tx] or AMask; |
2376 | 64 |
|
1859
e071284b118e
Pixels2 proc, which uses Land array when updating textures
unc0rr
parents:
1852
diff
changeset
|
65 |
Pixels2:= @tmpPixels |
e071284b118e
Pixels2 proc, which uses Land array when updating textures
unc0rr
parents:
1852
diff
changeset
|
66 |
end; |
e071284b118e
Pixels2 proc, which uses Land array when updating textures
unc0rr
parents:
1852
diff
changeset
|
67 |
|
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
68 |
procedure UpdateLandTexture(X, Width, Y, Height: LongInt; landAdded: boolean); |
1807 | 69 |
var tx, ty: Longword; |
10270 | 70 |
tSize : LongInt; |
1807 | 71 |
begin |
8027
e5ba3dd12531
make stats-only mode work headless. also skip a few things to save time/memory.
nemo
parents:
7850
diff
changeset
|
72 |
if cOnlyStats then exit; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6383
diff
changeset
|
73 |
if (Width <= 0) or (Height <= 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6383
diff
changeset
|
74 |
exit; |
11532 | 75 |
checkFails((X >= 0) and (X < LAND_WIDTH), 'UpdateLandTexture: wrong X parameter', true); |
76 |
checkFails(X + Width <= LAND_WIDTH, 'UpdateLandTexture: wrong Width parameter', true); |
|
77 |
checkFails((Y >= 0) and (Y < LAND_HEIGHT), 'UpdateLandTexture: wrong Y parameter', true); |
|
78 |
checkFails(Y + Height <= LAND_HEIGHT, 'UpdateLandTexture: wrong Height parameter', true); |
|
79 |
if not allOK then exit; |
|
1806 | 80 |
|
10270 | 81 |
tSize:= TEXSIZE; |
82 |
||
83 |
// land textures have half the size/resolution in blurry mode |
|
84 |
if (cReducedQuality and rqBlurryLand) <> 0 then |
|
85 |
tSize:= tSize * 2; |
|
86 |
||
87 |
for ty:= Y div tSize to (Y + Height - 1) div tSize do |
|
88 |
for tx:= X div tSize to (X + Width - 1) div tSize do |
|
89 |
begin |
|
90 |
if not LandTextures[tx, ty].shouldUpdate then |
|
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
91 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
92 |
LandTextures[tx, ty].shouldUpdate:= true; |
10270 | 93 |
inc(dirtyLandTexCount); |
94 |
end; |
|
95 |
LandTextures[tx, ty].landAdded:= landAdded |
|
96 |
end; |
|
1806 | 97 |
end; |
98 |
||
10268
1155384a4e31
"<unC0Rr> could also refuse to update textures when land changes if the tile isn't visible"
sheepluva
parents:
10267
diff
changeset
|
99 |
procedure RealLandTexUpdate(x1, x2, y1, y2: LongInt); |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
100 |
var x, y, ty, tx, lx, ly : LongWord; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
101 |
isEmpty: boolean; |
1806 | 102 |
begin |
8027
e5ba3dd12531
make stats-only mode work headless. also skip a few things to save time/memory.
nemo
parents:
7850
diff
changeset
|
103 |
if cOnlyStats then exit; |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
104 |
(* |
1807 | 105 |
if LandTextures[0, 0].tex = nil then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
106 |
for x:= 0 to LANDTEXARW -1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
107 |
for y:= 0 to LANDTEXARH - 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
108 |
with LandTextures[x, y] do |
3491 | 109 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6383
diff
changeset
|
110 |
tex:= NewTexture(TEXSIZE, TEXSIZE, Pixels(x, y)); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6383
diff
changeset
|
111 |
glBindTexture(GL_TEXTURE_2D, tex^.id); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6383
diff
changeset
|
112 |
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_PRIORITY, tpHigh); |
3491 | 113 |
end |
1806 | 114 |
else |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
115 |
*) |
10268
1155384a4e31
"<unC0Rr> could also refuse to update textures when land changes if the tile isn't visible"
sheepluva
parents:
10267
diff
changeset
|
116 |
for x:= x1 to x2 do |
1155384a4e31
"<unC0Rr> could also refuse to update textures when land changes if the tile isn't visible"
sheepluva
parents:
10267
diff
changeset
|
117 |
for y:= y1 to y2 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
118 |
with LandTextures[x, y] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
119 |
if shouldUpdate then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
120 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
121 |
shouldUpdate:= false; |
10270 | 122 |
dec(dirtyLandTexCount); |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
123 |
isEmpty:= not landAdded; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
124 |
landAdded:= false; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
125 |
ty:= 0; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
126 |
tx:= 1; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
127 |
ly:= y * TEXSIZE; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
128 |
lx:= x * TEXSIZE; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
129 |
// first check edges |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
130 |
while isEmpty and (ty < TEXSIZE) do |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
131 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
132 |
isEmpty:= LandPixels[ly + ty, lx] and AMask = 0; |
10494 | 133 |
if isEmpty then isEmpty:= LandPixels[ly + ty, Pred(lx + TEXSIZE)] and AMask = 0; |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
134 |
inc(ty) |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
135 |
end; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
136 |
while isEmpty and (tx < TEXSIZE-1) do |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
137 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
138 |
isEmpty:= LandPixels[ly, lx + tx] and AMask = 0; |
10494 | 139 |
if isEmpty then isEmpty:= LandPixels[Pred(ly + TEXSIZE), lx + tx] and AMask = 0; |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
140 |
inc(tx) |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
141 |
end; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
142 |
// then search every other remaining. does this sort of stuff defeat compiler opts? |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
143 |
ty:= 2; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
144 |
while isEmpty and (ty < TEXSIZE-1) do |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
145 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
146 |
tx:= 2; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
147 |
while isEmpty and (tx < TEXSIZE-1) do |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
148 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
149 |
isEmpty:= LandPixels[ly + ty, lx + tx] and AMask = 0; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
150 |
inc(tx,2) |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
151 |
end; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
152 |
inc(ty,2); |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
153 |
end; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
154 |
// and repeat |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
155 |
ty:= 1; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
156 |
while isEmpty and (ty < TEXSIZE-1) do |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
157 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
158 |
tx:= 1; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
159 |
while isEmpty and (tx < TEXSIZE-1) do |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
160 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
161 |
isEmpty:= LandPixels[ly + ty, lx + tx] and AMask = 0; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
162 |
inc(tx,2) |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
163 |
end; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
164 |
inc(ty,2); |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
165 |
end; |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
166 |
if not isEmpty then |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
167 |
begin |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
168 |
if tex = nil then tex:= NewTexture(TEXSIZE, TEXSIZE, Pixels(x, y)); |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
169 |
glBindTexture(GL_TEXTURE_2D, tex^.id); |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
170 |
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXSIZE, TEXSIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, Pixels(x,y)); |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
171 |
end |
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7151
diff
changeset
|
172 |
else if tex <> nil then |
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10494
diff
changeset
|
173 |
FreeAndNilTexture(tex); |
10270 | 174 |
|
175 |
// nothing else to do |
|
176 |
if dirtyLandTexCount < 1 then |
|
177 |
exit; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
178 |
end |
1806 | 179 |
end; |
180 |
||
1807 | 181 |
procedure DrawLand(dX, dY: LongInt); |
10267 | 182 |
var x, y, tX, ty, tSize, fx, lx, fy, ly: LongInt; |
10266 | 183 |
tScale: GLfloat; |
184 |
overlap: boolean; |
|
1806 | 185 |
begin |
10266 | 186 |
// init values based on quality settings |
187 |
if (cReducedQuality and rqBlurryLand) <> 0 then |
|
188 |
begin |
|
189 |
tSize:= TEXSIZE * 2; |
|
190 |
tScale:= 2.0; |
|
191 |
overlap:= (cReducedQuality and rqClampLess) <> 0; |
|
192 |
end |
|
193 |
else |
|
194 |
begin |
|
195 |
tSize:= TEXSIZE; |
|
196 |
tScale:= 1.0; |
|
197 |
overlap:= false; |
|
198 |
end; |
|
199 |
||
10267 | 200 |
// figure out visible area |
201 |
// first column |
|
202 |
tx:= ViewLeftX - dx; |
|
203 |
fx:= tx div tSize; |
|
204 |
if tx < 0 then dec(fx); |
|
205 |
fx:= max(0, fx); |
|
10266 | 206 |
|
10267 | 207 |
// last column |
208 |
tx:= ViewRightX - dx; |
|
209 |
lx:= tx div tSize; |
|
210 |
if tx < 0 then dec(lx); |
|
211 |
lx:= min(LANDTEXARW -1, lx); |
|
212 |
||
213 |
// all offscreen |
|
214 |
if (fx > lx) then |
|
215 |
exit; |
|
216 |
||
217 |
// first row |
|
218 |
ty:= ViewTopY - dy; |
|
219 |
fy:= ty div tSize; |
|
220 |
if ty < 0 then dec(fy); |
|
221 |
fy:= max(0, fy); |
|
10266 | 222 |
|
10267 | 223 |
// last row |
224 |
ty:= ViewBottomY - dy; |
|
225 |
ly:= ty div tSize; |
|
226 |
if ty < 0 then dec(ly); |
|
227 |
ly:= min(LANDTEXARH -1, ly); |
|
10266 | 228 |
|
10267 | 229 |
// all offscreen |
230 |
if (fy > ly) then |
|
231 |
exit; |
|
232 |
||
10269 | 233 |
// update visible areas of landtex before drawing |
10270 | 234 |
if dirtyLandTexCount > 0 then |
235 |
RealLandTexUpdate(fx, lx, fy, ly); |
|
10268
1155384a4e31
"<unC0Rr> could also refuse to update textures when land changes if the tile isn't visible"
sheepluva
parents:
10267
diff
changeset
|
236 |
|
10267 | 237 |
tX:= dX + tsize * fx; |
10266 | 238 |
|
10267 | 239 |
// loop through columns |
240 |
for x:= fx to lx do |
|
241 |
begin |
|
242 |
// loop through textures in this column |
|
243 |
for y:= fy to ly do |
|
244 |
with LandTextures[x, y] do |
|
245 |
if tex <> nil then |
|
246 |
begin |
|
247 |
ty:= dY + y * tSize; |
|
248 |
if overlap then |
|
249 |
DrawTexture2(tX, ty, tex, tScale, BLURRYLANDOVERLAP) |
|
250 |
else |
|
251 |
DrawTexture(tX, ty, tex, tScale); |
|
252 |
end; |
|
10266 | 253 |
|
10267 | 254 |
// increment tX |
10266 | 255 |
inc(tX, tSize); |
256 |
end; |
|
1807 | 257 |
end; |
258 |
||
7850 | 259 |
procedure SetLandTexture; |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
260 |
begin |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
261 |
if (cReducedQuality and rqBlurryLand) = 0 then |
5654 | 262 |
begin |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
263 |
LANDTEXARW:= LAND_WIDTH div TEXSIZE; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
264 |
LANDTEXARH:= LAND_HEIGHT div TEXSIZE; |
5654 | 265 |
end |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
266 |
else |
5654 | 267 |
begin |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
268 |
LANDTEXARW:= (LAND_WIDTH div TEXSIZE) div 2; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
269 |
LANDTEXARH:= (LAND_HEIGHT div TEXSIZE) div 2; |
5654 | 270 |
end; |
3697 | 271 |
|
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
272 |
SetLength(LandTextures, LANDTEXARW, LANDTEXARH); |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
273 |
end; |
3697 | 274 |
|
7850 | 275 |
procedure initModule; |
276 |
begin |
|
277 |
end; |
|
278 |
||
5654 | 279 |
procedure ResetLand; |
3615 | 280 |
var x, y: LongInt; |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
281 |
begin |
6382
0e76c5cd4250
move the order of reloading texture to workaround buggy drivers
koda
parents:
6380
diff
changeset
|
282 |
for x:= 0 to LANDTEXARW - 1 do |
3615 | 283 |
for y:= 0 to LANDTEXARH - 1 do |
284 |
with LandTextures[x, y] do |
|
10648 | 285 |
FreeAndNilTexture(tex); |
5654 | 286 |
end; |
287 |
||
288 |
procedure freeModule; |
|
289 |
begin |
|
290 |
ResetLand; |
|
3615 | 291 |
if LandBackSurface <> nil then |
292 |
SDL_FreeSurface(LandBackSurface); |
|
293 |
LandBackSurface:= nil; |
|
7151 | 294 |
SetLength(LandTextures, 0, 0); |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3595
diff
changeset
|
295 |
end; |
1806 | 296 |
end. |