-
Notifications
You must be signed in to change notification settings - Fork 12
/
circles.lua
511 lines (384 loc) · 13.8 KB
/
circles.lua
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
if SERVER then return false end
local _R = debug.getregistry()
if _R.Circles then return _R.Circles end
local CIRCLE = {}
CIRCLE.__index = CIRCLE
CIRCLE_FILLED = 0
CIRCLE_OUTLINED = 1
CIRCLE_BLURRED = 2
local New do
local err_number = "bad argument #%i to 'New' (number expected, got %s)"
function New(t, r, x, y, ...)
assert(isnumber(t), string.format(err_number, 1, type(t)))
assert(isnumber(r), string.format(err_number, 2, type(r)))
assert(isnumber(x), string.format(err_number, 3, type(x)))
assert(isnumber(y), string.format(err_number, 4, type(y)))
local circle = setmetatable({}, CIRCLE)
circle:SetType(t)
circle:SetRadius(r)
circle:SetX(x)
circle:SetY(y)
circle:SetVertices({[0] = 0})
if t == CIRCLE_OUTLINED then
local outline_width = ...
assert(outline_width == nil or isnumber(outline_width), string.format(err_number, 5, type(outline_width)))
circle:SetOutlineWidth(outline_width)
elseif t == CIRCLE_BLURRED then
local blur_layers, blur_density = ...
assert(blur_layers == nil or isnumber(blur_layers), string.format(err_number, 5, type(blur_layers)))
assert(blur_density == nil or isnumber(blur_density), string.format(err_number, 6, type(blur_density)))
circle:SetBlurLayers(blur_layers)
circle:SetBlurDensity(blur_density)
end
return circle
end
end
local RotateVertices do
local err_table = "bad argument #1 to 'RotateVertices' (table expected, got %s)"
local err_number = "bad argument #%i to 'RotateVertices' (number expected, got %s)"
function RotateVertices(vertices, ox, oy, rotation, rotate_uv)
assert(istable(vertices), string.format(err_table, type(vertices)))
assert(isnumber(ox), string.format(err_number, 2, type(ox)))
assert(isnumber(oy), string.format(err_number, 3, type(oy)))
assert(isnumber(rotation), string.format(err_number, 4, type(rotation)))
local rotation = math.rad(rotation)
local c = math.cos(rotation)
local s = math.sin(rotation)
for i = 1, vertices[0] or #vertices do
local vertex = vertices[i]
local vx, vy = vertex.x, vertex.y
vx = vx - ox
vy = vy - oy
vertex.x = ox + (vx * c - vy * s)
vertex.y = oy + (vx * s + vy * c)
if rotate_uv == false then
local u, v = vertex.u, vertex.v
u, v = u - 0.5, v - 0.5
vertex.u = 0.5 + (u * c - v * s)
vertex.v = 0.5 + (u * s + v * c)
end
end
end
end
local CalculateVertices do
local err_number = "bad argument #%i to 'CalculateVertices' (number expected, got %s)"
function CalculateVertices(x, y, radius, rotation, start_angle, end_angle, distance, rotate_uv)
assert(isnumber(x), string.format(err_number, 1, type(x)))
assert(isnumber(y), string.format(err_number, 2, type(y)))
assert(isnumber(radius), string.format(err_number, 3, type(radius)))
assert(isnumber(rotation), string.format(err_number, 4, type(rotation)))
assert(isnumber(start_angle), string.format(err_number, 5, type(start_angle)))
assert(isnumber(end_angle), string.format(err_number, 6, type(end_angle)))
assert(isnumber(distance), string.format(err_number, 7, type(distance)))
local vertices = {}
local vertex_count = 0
local step = distance / radius
local rad_start_angle = math.rad(start_angle)
local rad_end_angle = math.rad(end_angle)
local rad_rotation = math.rad(rotation)
for a = rad_start_angle, rad_end_angle + step, step do
a = math.min(a, rad_end_angle)
local c = math.cos(a + rad_rotation)
local s = math.sin(a + rad_rotation)
local vertex = {
x = x + c * radius,
y = y + s * radius,
}
if rotate_uv == false then
vertex.u = 0.5 + math.cos(a) / 2
vertex.v = 0.5 + math.sin(a) / 2
else
vertex.u = 0.5 + c / 2
vertex.v = 0.5 + s / 2
end
vertex_count = vertex_count + 1
vertices[vertex_count] = vertex
end
if end_angle - start_angle ~= 360 then
table.insert(vertices, 1, {
x = x, y = y,
u = 0.5, v = 0.5,
})
vertex_count = vertex_count + 1
else
table.remove(vertices)
vertex_count = vertex_count - 1
end
vertices[0] = vertex_count
return vertices
end
end
function CIRCLE:__tostring()
return string.format("Circle: %p", self)
end
function CIRCLE:Copy()
return table.Copy(self)
end
function CIRCLE:IsValid()
return (
not self.m_Dirty and
self.m_Vertices[0] >= 3 and
self.m_Radius >= 1 and
self.m_Distance >= 1
)
end
function CIRCLE:Calculate()
local rotate_uv = self.m_RotateMaterial
local radius = self.m_Radius
local x, y = self.m_X, self.m_Y
local rotation = self.m_Rotation
local start_angle = self.m_StartAngle
local end_angle = self.m_EndAngle
local distance = self.m_Distance
assert(radius >= 1, string.format("circle radius should be >= 1 (%.4f)", radius))
assert(distance >= 1, string.format("circle distance should be >= 1 (%.4f)", distance))
self:SetVertices(CalculateVertices(x, y, radius, rotation, start_angle, end_angle, distance, rotate_uv))
if self.m_Type == CIRCLE_OUTLINED then
local inner = self.m_ChildCircle or self:Copy()
local inner_r = radius - self.m_OutlineWidth
inner:SetType(CIRCLE_FILLED)
inner:SetPos(x, y)
inner:SetRadius(inner_r)
inner:SetRotation(rotation)
inner:SetAngles(start_angle, end_angle)
inner:SetDistance(distance)
inner:SetColor(false)
inner:SetMaterial(false)
inner:SetShouldRender(inner_r >= 1)
inner:SetDirty(inner.m_ShouldRender)
self:SetShouldRender(inner_r < radius)
self:SetChildCircle(inner)
elseif self.m_ChildCircle then
self.m_ChildCircle = nil
end
self:SetDirty(false)
return self
end
do
local blur = Material("pp/blurscreen")
function CIRCLE:__call()
if self.m_Dirty then self:Calculate() end
if not self:IsValid() then return false end
if not self.m_ShouldRender then return false end
do
local col, mat = self.m_Color, self.m_Material
if IsColor(col) then
if col.a <= 0 then return end
surface.SetDrawColor(col.r, col.g, col.b, col.a)
end
if mat == true then
draw.NoTexture()
elseif TypeID(mat) == TYPE_MATERIAL then
surface.SetMaterial(mat)
end
end
if self.m_Type == CIRCLE_OUTLINED then
render.ClearStencil()
render.SetStencilEnable(true)
render.SetStencilTestMask(0xFF)
render.SetStencilWriteMask(0xFF)
render.SetStencilReferenceValue(0x01)
render.SetStencilCompareFunction(STENCIL_NEVER)
render.SetStencilFailOperation(STENCIL_REPLACE)
render.SetStencilZFailOperation(STENCIL_REPLACE)
self.m_ChildCircle()
render.SetStencilCompareFunction(STENCIL_GREATER)
render.SetStencilFailOperation(STENCIL_KEEP)
render.SetStencilZFailOperation(STENCIL_KEEP)
surface.DrawPoly(self.m_Vertices)
render.SetStencilEnable(false)
elseif self.m_Type == CIRCLE_BLURRED then
render.ClearStencil()
render.SetStencilEnable(true)
render.SetStencilTestMask(0xFF)
render.SetStencilWriteMask(0xFF)
render.SetStencilReferenceValue(0x01)
render.SetStencilCompareFunction(STENCIL_NEVER)
render.SetStencilFailOperation(STENCIL_REPLACE)
render.SetStencilZFailOperation(STENCIL_REPLACE)
surface.DrawPoly(self.m_Vertices)
render.SetStencilCompareFunction(STENCIL_LESSEQUAL)
render.SetStencilFailOperation(STENCIL_KEEP)
render.SetStencilZFailOperation(STENCIL_KEEP)
surface.SetMaterial(blur)
local sw, sh = ScrW(), ScrH()
for i = 1, self.m_BlurLayers do
blur:SetFloat("$blur", (i / self.m_BlurLayers) * self.m_BlurDensity)
blur:Recompute()
render.UpdateScreenEffectTexture()
surface.DrawTexturedRect(0, 0, sw, sh)
end
render.SetStencilEnable(false)
else
surface.DrawPoly(self.m_Vertices)
end
return true
end
CIRCLE.Draw = CIRCLE.__call
end
do
local err_number = "bad argument #%i to 'Translate' (number expected, got %s)"
function CIRCLE:Translate(x, y)
assert(isnumber(x), string.format(err_number, 1, type(x)))
assert(isnumber(y), string.format(err_number, 2, type(y)))
if x ~= 0 or y ~= 0 then
self.m_X = self.m_X + x
self.m_Y = self.m_Y + y
if self:IsValid() then
for i = 1, self.m_Vertices[0] do
local vertex = self.m_Vertices[i]
vertex.x = vertex.x + x
vertex.y = vertex.y + y
end
if self.m_Type == CIRCLE_OUTLINED and self.m_ChildCircle then
self.m_ChildCircle:Translate(x, y)
end
end
end
return self
end
end
do
local err_number = "bad argument #1 to 'Scale' (number expected, got %s)"
function CIRCLE:Scale(scale)
assert(isnumber(scale), string.format(err_number, type(scale)))
if scale ~= 1 then
self.m_Radius = self.m_Radius * scale
if self:IsValid() then
local x, y = self.m_X, self.m_Y
for i = 1, self.m_Vertices[0] do
local vertex = self.m_Vertices[i]
vertex.x = x + (vertex.x - x) * scale
vertex.y = y + (vertex.y - y) * scale
end
if self.m_Type == CIRCLE_OUTLINED and self.m_ChildCircle then
self.m_ChildCircle:Scale(scale)
end
end
end
return self
end
end
do
local err_number = "bad argument #1 to 'Rotate' (number expected, got %s)"
function CIRCLE:Rotate(rotation)
assert(isnumber(rotation), string.format(err_number, type(rotation)))
if rotation ~= 0 then
self.m_Rotation = self.m_Rotation + rotation
if self:IsValid() then
local x, y = self.m_X, self.m_Y
local vertices = self.m_Vertices
local rotate_uv = self.m_RotateMaterial
RotateVertices(vertices, x, y, rotation, rotate_uv)
if self.m_Type == CIRCLE_OUTLINED and self.m_ChildCircle then
self.m_ChildCircle:Rotate(rotation)
end
end
end
return self
end
end
do
local function AccessorFunc(name, default, dirty, callback)
local varname = "m_" .. name
CIRCLE["Get" .. name] = function(self)
return self[varname]
end
CIRCLE["Set" .. name] = function(self, value)
if default ~= nil and value == nil then
value = default
end
if self[varname] ~= value then
if dirty then
self[dirty] = true
end
if callback ~= nil then
local new = callback(self, self[varname], value)
value = new ~= nil and new or value
end
self[varname] = value
end
return self
end
CIRCLE[varname] = default
end
local function OffsetVerticesX(circle, old, new)
circle:Translate(new - old, 0)
if circle.m_Type == CIRCLE_OUTLINED and circle.m_ChildCircle then
circle.m_ChildCircle:Translate(new - old, 0)
end
end
local function OffsetVerticesY(circle, old, new)
circle:Translate(0, new - old)
if circle.m_Type == CIRCLE_OUTLINED and circle.m_ChildCircle then
circle.m_ChildCircle:Translate(0, new - old)
end
end
local function UpdateRotation(circle, old, new)
circle:Rotate(new - old)
if circle.m_Type == CIRCLE_OUTLINED and circle.m_ChildCircle then
circle.m_ChildCircle:Rotate(new - old)
end
end
-- These are set internally. Only use them if you know what you're doing.
AccessorFunc("Dirty", true)
AccessorFunc("Vertices", false)
AccessorFunc("ChildCircle", false)
AccessorFunc("ShouldRender", true)
AccessorFunc("Color", false) -- The colour you want the circle to be. If set to false then surface.SetDrawColor's can be used.
AccessorFunc("Material", false) -- The material you want the circle to render. If set to false then surface.SetMaterial can be used.
AccessorFunc("RotateMaterial", true) -- Sets whether or not the circle's UV points should be rotated with the vertices.
AccessorFunc("Type", CIRCLE_FILLED, "m_Dirty") -- The circle's type.
AccessorFunc("X", 0, false, OffsetVerticesX) -- The circle's X position relative to the top left of the screen.
AccessorFunc("Y", 0, false, OffsetVerticesY) -- The circle's Y position relative to the top left of the screen.
AccessorFunc("Radius", 8, "m_Dirty") -- The circle's radius.
AccessorFunc("Rotation", 0, false, UpdateRotation) -- The circle's rotation, measured in degrees.
AccessorFunc("StartAngle", 0, "m_Dirty") -- The circle's start angle, measured in degrees.
AccessorFunc("EndAngle", 360, "m_Dirty") -- The circle's end angle, measured in degrees.
AccessorFunc("Distance", 10, "m_Dirty") -- The maximum distance between each of the circle's vertices. This should typically be used for large circles in 3D2D.
AccessorFunc("BlurLayers", 3) -- The circle's blur layers if Type is set to CIRCLE_BLURRED.
AccessorFunc("BlurDensity", 2) -- The circle's blur density if Type is set to CIRCLE_BLURRED.
AccessorFunc("OutlineWidth", 10, "m_Dirty") -- The circle's outline width if Type is set to CIRCLE_OUTLINED.
function CIRCLE:SetPos(x, y)
x = tonumber(x) or self.m_X
y = tonumber(y) or self.m_Y
if self:IsValid() then
self:Translate(x - self.m_X, y - self.m_Y)
else
self.m_X = x
self.m_Y = y
end
return self
end
function CIRCLE:SetAngles(s, e)
s = tonumber(s) or self.m_StartAngle
e = tonumber(e) or self.m_EndAngle
self:SetDirty(self.m_Dirty or s ~= self.m_StartAngle or e ~= self.m_EndAngle)
self.m_StartAngle = s
self.m_EndAngle = e
return self
end
function CIRCLE:GetPos()
return self.m_X, self.m_Y
end
function CIRCLE:GetAngles()
return self.m_StartAngle, self.m_EndAngle
end
function CIRCLE:SetVertexCount(count)
self:SetDistance(math.tau * self.m_Radius / math.floor(0.5 + count))
return self
end
function CIRCLE:GetVertexCount()
if self.m_Dirty then
return math.ceil(math.tau * self.m_Radius / self.m_Distance) -- rough estimate, only accounts for full circles, m_Vertices[0] will always be right.
end
return self.m_Vertices[0]
end
end
_R.Circles = {
_MT = CIRCLE,
New = New,
RotateVertices = RotateVertices,
CalculateVertices = CalculateVertices,
}
return _R.Circles