Rendu 3D et effets

Côté client : placer un texte au-dessus d'un joueur, dessiner des panneaux dans le monde (3D2D), afficher des images et ses propres polices, entourer des objets (halos), tracer des formes de débogage, dessiner faisceaux, sprites et maillages en 3D (avec stencils), créer des particules, des effets Lua (EFFECT) et des décalcomanies, allumer des lumières dynamiques et des projecteurs, teinter, flouter ou styliser l'écran, et afficher des modèles visibles par un seul joueur.

Hooks de rendu

Les deux arguments (bDrawingDepth, bDrawingSkybox dans GMod) valent toujours false. Le HUD 2D reste dessiné dans HUDPaint.

Ordre dans une image : PreRender → début du dessin 3D de l'image (les particules des ParticleEmitter bougent, les EFFECT font Think puis Render, les DynamicLight sont placées) → PreDrawHalos → RenderScreenspaceEffects → PostRender → puis, pendant le dessin de l'interface, PostDrawOpaqueRenderables et PostDrawTranslucentRenderables.

Position à l'écran : ToScreen

vec:ToScreen() → table donne { x, y, visible, onscreen } :

• x, y : position du point dans les mêmes coordonnées que ScrW() / ScrH() et draw.*. Rien à convertir, même si le jeu étire l'image selon le format de l'écran.
• visible : le point est devant la caméra (il peut quand même être hors de l'écran, comme dans GMod).
• onscreen : devant la caméra et dans le rectangle de l'écran.
• Sans caméra 3D active : {x = 0, y = 0, visible = false, onscreen = false}.

-- Nom et santé au-dessus de la tête des autres joueurs.
hook.Add("HUDPaint", "NomsAuDessus", function()
	local moi = LocalPlayer()
	for _, ply in ipairs(player.GetAll()) do
		if ply ~= moi and ply:Alive() and ply:GetPos():Distance(moi:GetPos()) < 25 then
			local s = (ply:GetPos() + Vector(0, 2.1, 0)):ToScreen()
			if s.onscreen then
				draw.SimpleText(ply:Nick(), "Bold", s.x, s.y, Color(255, 255, 255), TEXT_ALIGN_CENTER, TEXT_ALIGN_BOTTOM)
				draw.SimpleText(ply:Health() .. " PV", "Small", s.x, s.y + 2, Color(120, 255, 120), TEXT_ALIGN_CENTER, TEXT_ALIGN_TOP)
			end
		end
	end
end)

Dessiner dans le monde : cam.Start3D2D

cam.Start3D2D(pos, ang, échelle) … cam.End3D2D(), uniquement dans le hook PostDrawOpaqueRenderables (ou PostDrawTranslucentRenderables) ; ailleurs, une erreur s'affiche une fois. Entre les deux, draw.SimpleText, draw.RoundedBox, surface.DrawRect, surface.DrawText, surface.DrawTexturedRect… dessinent sur un panneau placé dans le monde au lieu du HUD.

Pour tourner le panneau vers un point cible : local d = cible - pos puis Vector(0, math.deg(math.atan(d.x, d.z)), 0) (en Lua 5.4, math.atan2 n'existe pas : math.atan(y, x) prend deux arguments).

-- Prix affiché au-dessus des entités de la classe « vente ».
surface.CreateFont("PrixGros", { font = "Barlow", size = 64, weight = 700 })

hook.Add("PostDrawOpaqueRenderables", "PanneauxPrix", function()
	local oeil = LocalPlayer():EyePos()
	for _, ent in ipairs(ents.FindByClass("vente")) do
		local pos = ent:GetPos() + Vector(0, 1.2, 0)
		if (pos - oeil):Length() < 15 then
			local d = oeil - pos
			local ang = Vector(0, math.deg(math.atan(d.x, d.z)), 0) -- face au joueur
			cam.Start3D2D(pos, ang, 0.005)
				draw.RoundedBox(12, -160, -50, 320, 100, Color(20, 20, 20, 220))
				draw.SimpleText(ent:GetNWInt("prix", 0) .. " $", "PrixGros", 0, 0, Color(255, 210, 60), TEXT_ALIGN_CENTER, TEXT_ALIGN_CENTER)
			cam.End3D2D()
		end
	end
end)

Images : Material

Material(chemin) → matériau charge une image d'un dossier materials/ du gamemode ou d'un addon activé ("mon_addon/logo.png"), ou une image intégrée : "physicore/logo.png", "physicore/icon_physgun.png", "physicore/icon_toolgun.png", et pour les particules et sprites "physicore/particle_glow.png" (halo lumineux), "physicore/particle_smoke.png" (fumée), "physicore/particle_spark.png" (étincelle). Comme pour les sons, les autres joueurs ne voient que les images du jeu et du Workshop (celles d'un addon local restent chez l'hôte). Formats : .png, .jpg, .jpeg, .webp, .svg (4096 px au plus). Image introuvable : erreur affichée et :IsError() vaut true. Crée le matériau une fois (hors de HUDPaint) et garde-le dans une variable.

Ces fonctions marchent dans HUDPaint et dans un panneau 3D2D. Les panneaux DImage affichent aussi des images dans les fenêtres.

local logo = Material("mon_gamemode/logo.png")
local fleche = Material("mon_gamemode/fleche.png")

hook.Add("HUDPaint", "Logo", function()
	if logo:IsError() then return end
	surface.SetDrawColor(255, 255, 255, 230)
	surface.SetMaterial(logo)
	surface.DrawTexturedRect(20, 20, logo:Width() / 4, logo:Height() / 4)
	-- La flèche tourne avec le regard du joueur.
	local aim = LocalPlayer():GetAimVector()
	surface.SetMaterial(fleche)
	surface.DrawTexturedRectRotated(ScrW() - 60, 60, 64, 64, math.deg(math.atan(aim.x, -aim.z)))
end)

Polices : surface.CreateFont

surface.CreateFont(nom, options) crée (ou remplace) une police utilisable partout où un nom de police est demandé (draw.SimpleText, draw.GetFontHeight, surface.SetFont, SetFont des panneaux…). 128 polices au plus ; elles sont effacées quand les scripts sont rechargés.

Écrire avec surface

-- Bandeau d'argent en deux couleurs.
surface.CreateFont("Argent", { font = "Barlow Condensed", size = 40, weight = 700, outline = true })

hook.Add("HUDPaint", "Argent", function()
	local argent = LocalPlayer():GetNWInt("argent", 0)
	surface.SetFont("Argent")
	local l1 = surface.GetTextSize("Argent : ")
	local l2, h = surface.GetTextSize(argent .. " $")
	local x = ScrW() - l1 - l2 - 30
	draw.RoundedBox(8, x - 10, 20, l1 + l2 + 20, h + 10, Color(0, 0, 0, 160))
	surface.SetTextPos(x, 25)
	surface.SetTextColor(255, 255, 255)
	surface.DrawText("Argent : ")
	surface.SetTextColor(Color(120, 255, 120))
	surface.DrawText(argent .. " $")
end)

Contours : halo.Add

halo.Add(entités, couleur, flou_x, flou_y, passes, additif, à_travers_murs) (seuls les deux premiers sont obligatoires), à appeler chaque image depuis le hook PreDrawHalos : le contour ne dure que l'image en cours.

• entités : une table d'entités (props, entités scriptées, joueurs, modèles ClientsideModel) ou une seule entité.
• couleur : Color (blanc par défaut). L'alpha ne sert qu'avec à_travers_murs.
• flou_x (2 par défaut, de 0 à 10) : épaisseur du contour, à peu près la même à l'écran de près comme de loin. flou_y, passes et additif sont acceptés pour la compatibilité GMod mais ignorés.
• à_travers_murs (false par défaut) : true = silhouette colorée semi-transparente visible à travers le décor.
• 64 entités et 256 maillages au plus par image. Le contour est une « coque inversée », pas un vrai flou : sur les modèles à arêtes vives (caisses), il peut présenter de petites coupures aux coins.

-- Contour sur le prop visé et sur les coéquipiers.
hook.Add("PreDrawHalos", "Contours", function()
	local tr = LocalPlayer():GetEyeTrace()
	if tr.Entity and IsValid(tr.Entity) and not tr.Entity:IsPlayer() and tr.HitPos:Distance(tr.StartPos) < 8 then
		halo.Add({ tr.Entity }, Color(255, 200, 0), 2)
	end
	local amis = {}
	for _, ply in ipairs(player.GetAll()) do
		if ply ~= LocalPlayer() and ply:Team() == LocalPlayer():Team() then amis[#amis + 1] = ply end
	end
	halo.Add(amis, Color(80, 160, 255, 200), 1, 1, 1, true, true)
end)

Formes de débogage : render.Draw*

Formes 3D valables pour l'image en cours : à appeler chaque image depuis PostDrawOpaqueRenderables (depuis Think, elles clignoteraient). Non éclairées, couleurs avec alpha, 60 000 sommets au plus par image.

-- Visualiser la zone d'un objectif.
hook.Add("PostDrawOpaqueRenderables", "ZoneObjectif", function()
	local centre = GetGlobalVector("objectif", Vector(0, 0, 0))
	render.DrawWireframeBox(centre, Vector(0, 0, 0), Vector(-3, 0, -3), Vector(3, 2, 3), Color(255, 80, 80), true)
	render.DrawSphere(centre + Vector(0, 2.5, 0), 0.3, Color(255, 80, 80, 150))
	render.DrawLine(LocalPlayer():GetPos(), centre, Color(255, 255, 255, 120))
end)

Dessin 3D de l'image : faisceaux, sprites, quads

Comme dans GMod, on peut dessiner des formes texturées dans le monde : faisceaux (lasers, éclairs), sprites toujours face à la caméra (lueurs), quadrilatères et maillages. Ce dessin ne vaut que pour une image : appelle ces fonctions à chaque image depuis un hook de rendu (PostDrawOpaqueRenderables ou PostDrawTranslucentRenderables en général ; aussi PreDrawHalos, RenderScreenspaceEffects, PostRender, ou EFFECT:Render). Ce qui est dessiné pendant une image est affiché à l'image suivante (un décalage d'environ 16 ms, invisible sauf sur un objet très rapide), puis oublié.

Tout est non éclairé, visible des deux côtés, avec la transparence de la couleur. Positions et tailles en mètres, dans le monde. Couleurs : Color(…) (blanc par défaut).

Matériau et mélange

Ces réglages s'appliquent au dessin qui suit ; ils reviennent à leur valeur par défaut au début de chaque image.

Formes

-- Un laser rouge depuis les yeux du joueur, avec une lueur au point d'impact.
local lueur = Material("physicore/particle_glow.png")

hook.Add("PostDrawTranslucentRenderables", "laser", function()
	local ply = LocalPlayer()
	if not ply:Alive() then return end
	local tr = ply:GetEyeTrace()
	local depart = ply:EyePos() + ply:GetRight() * 0.15 - Vector(0, 0.1, 0)
	render.SetColorMaterial()
	render.DrawBeam(depart, tr.HitPos, 0.02, 0, 1, Color(255, 30, 30, 200))
	render.SetMaterial(lueur)                  -- « glow » : additif
	render.DrawSprite(tr.HitPos, 0.4, 0.4, Color(255, 60, 60))
end)

Maillages : mesh et Mesh()

Pour des formes libres, l'API immédiate de GMod : mesh.Begin(type, nombre), puis pour chaque sommet mesh.Position(v), mesh.Color(r, g, b, a) (0 à 255), mesh.TexCoord(0, u, v), mesh.AdvanceVertex(), et enfin mesh.End(). Types : MATERIAL_TRIANGLES (3 sommets par triangle), MATERIAL_QUADS (4 par quadrilatère), MATERIAL_TRIANGLE_STRIP, MATERIAL_POLYGON (polygone convexe en éventail). nombre est ignoré, mesh.Normal et mesh.UserData ne font rien (pas d'éclairage). Aussi mesh.Quad(a, b, c, d, couleur) et mesh.QuadEasy(pos, normale, l, h, couleur).

Mesh() crée un maillage à construire une fois et à redessiner à chaque image : m:BuildFromTriangles({ {pos = Vector, u = 0, v = 0, color = Color}, … }) (3 sommets par triangle), m:Draw() (avec le matériau en cours), m:GetVertexCount(), m:Destroy(), m:IsValid(). Les positions sont dans le monde : il n'y a pas de matrice de modèle (cam.PushModelMatrix), recalcule les sommets pour déplacer la forme.

-- Un triangle aux couleurs dégradées au-dessus de l'origine de la map.
hook.Add("PostDrawOpaqueRenderables", "triangle", function()
	render.SetColorMaterial()
	mesh.Begin(MATERIAL_TRIANGLES, 1)
		mesh.Position(Vector(-1, 2, 0)) mesh.Color(255, 0, 0, 255) mesh.AdvanceVertex()
		mesh.Position(Vector(1, 2, 0))  mesh.Color(0, 255, 0, 255) mesh.AdvanceVertex()
		mesh.Position(Vector(0, 3.5, 0)) mesh.Color(0, 0, 255, 255) mesh.AdvanceVertex()
	mesh.End()
end)

Stencils

Le stencil limite le dessin à une zone dessinée avant : par exemple une « fenêtre » ou un portail. Il ne s'applique qu'au dessin 3D de cette section (formes, mesh, particules), pas aux modèles du jeu.

-- Un cadre écrit la valeur 1, puis la lueur n'apparaît que dans le cadre.
local lueur = Material("physicore/particle_glow.png")
hook.Add("PostDrawTranslucentRenderables", "fenetre", function()
	local centre = Vector(0, 2, -4)
	render.SetStencilEnable(true)
	render.SetStencilReferenceValue(1)
	render.SetStencilCompareFunction(STENCIL_ALWAYS)
	render.SetStencilPassOperation(STENCIL_REPLACE)
	render.SetColorMaterial()
	render.DrawQuadEasy(centre, Vector(0, 0, 1), 2, 2, Color(20, 20, 40))
	render.SetStencilCompareFunction(STENCIL_EQUAL)
	render.SetStencilPassOperation(STENCIL_KEEP)
	render.SetMaterial(lueur)
	render.DrawSprite(centre + Vector(math.sin(CurTime()) * 1.5, 0, 0.1), 1.5, 1.5, Color(255, 200, 80))
	render.SetStencilEnable(false)
end)

Particules

effects.Particles(pos, options) → booléen

Une gerbe de particules éphémères (carrés toujours face à la caméra, non éclairés, qui s'estompent). Renvoie true si l'effet a été créé. Options, toutes facultatives :

64 gerbes vivantes et 2 000 particules au total au plus (au-delà, la gerbe est réduite ou refusée et la fonction renvoie false).

Émetteurs de particules : ParticleEmitter

Pour contrôler chaque particule, comme dans GMod : ParticleEmitter(pos, use3D) → émetteur, puis emetteur:Add(matériau, pos) → particule ou nil pour chaque particule. matériau : un Material(…) ou un chemin (par exemple les images intégrées "physicore/particle_glow.png", "physicore/particle_smoke.png", "physicore/particle_spark.png"). Une image dont le nom contient glow, light, flare ou fire est dessinée en additif (lumineuse). Les particules sont des carrés toujours face à la caméra, non éclairés, dessinés avec le dessin 3D de l'image.

Chaque Set… a son Get… (GetColor() renvoie trois valeurs). SetAngles, SetAngleVelocity, SetLighting, SetStartLength / SetEndLength et SetVelocityScale gardent leur valeur mais ne changent pas l'affichage. Émetteur : SetPos(v) / GetPos() (position par défaut des particules ajoutées), GetNumActiveParticles(), SetNoDraw(bool), Is3D(), IsValid(), Finish() (l'émetteur disparaît quand ses dernières particules sont mortes ; appelle-le quand tu n'en ajoutes plus). 1 024 particules par émetteur et 4 096 en tout au plus : au-delà, Add renvoie nil.

-- Une fontaine d'étincelles pendant 3 secondes.
local etincelle = Material("physicore/particle_spark.png")

local function fontaine(pos)
	local em = ParticleEmitter(pos)
	timer.Create("fontaine", 0.05, 60, function()
		for i = 1, 4 do
			local p = em:Add(etincelle, pos)
			if p then
				p:SetVelocity(VectorRand() * 1.5 + Vector(0, 5, 0))
				p:SetGravity(Vector(0, -9.8, 0))
				p:SetDieTime(1.2)
				p:SetStartSize(0.08) p:SetEndSize(0)
				p:SetColor(255, 180, 60)
				p:SetCollide(true) p:SetBounce(0.4)
			end
		end
	end)
	timer.Simple(3.1, function() em:Finish() end)
end

util.Effect(nom, données) → booléen

Joue un effet, comme dans GMod, avec un objet EffectData() : data:SetOrigin(v), SetNormal(v), SetScale(n)… Le nom (majuscules indifférentes) désigne un effet Lua (EFFECT), sinon un effet intégré : "Sparks" (étincelles), "BloodImpact", "Explosion", "WaterSplash", "Dust", "Smoke". Un effet intégré utilise Origin (position), Normal (direction), Scale (0,1 à 10, multiplie taille et vitesse) et Color ; un nom inconnu affiche une erreur et renvoie false.

Champs de EffectData() (chacun avec Set… et Get…, nil s'il n'a pas été donné) : Origin, Start, Normal, Angles, Magnitude, Scale, Radius, Entity, Flags, Color, SurfaceProp, HitBox, AttachmentNumber, DamageType, MaterialIndex, EntIndex. Ils contiennent ce que tu veux (nombre, Vector, Color, entité…).

Côté serveur, util.Effect(nom, données) joue l'effet chez tous les joueurs (chacun le joue avec son Lua client ; l'entité arrive comme une entité de chez lui) et renvoie true. Côté client, il ne le joue que pour ce joueur.

Effets en Lua : EFFECT

Un effet Lua est une table EFFECT, côté client seulement, déclarée par un fichier :

Pendant le chargement du fichier, la table globale EFFECT est prête ; le nom de l'effet est le nom du fichier sans .lua, en minuscules. Aussi effects.Create(nom) (la table EFFECT ou nil) et effects.GetList() (les noms). Chaque util.Effect crée un objet qui hérite de la table :

-- lua/effects/onde_choc.lua (addon) : un anneau lumineux qui s'élargit pendant 0,6 s.
local lueur = Material("physicore/particle_glow.png")

function EFFECT:Init(data)
	self.Pos = data:GetOrigin() or Vector(0, 0, 0)
	self.Taille = data:GetScale() or 1
	self.Fin = CurTime() + 0.6
end

function EFFECT:Think()
	return CurTime() < self.Fin          -- false à la fin : l'effet est supprimé
end

function EFFECT:Render()
	local f = 1 - (self.Fin - CurTime()) / 0.6
	render.SetMaterial(lueur)
	render.DrawQuadEasy(self.Pos + Vector(0, 0.05, 0), Vector(0, 1, 0), 6 * f * self.Taille, 6 * f * self.Taille,
		Color(120, 200, 255, 255 * (1 - f)))
end

-- Serveur : une onde de choc chez tous les joueurs à l'atterrissage d'un joueur.
hook.Add("OnPlayerHitGround", "onde", function(ply, eau, flotteur, vitesse)
	if vitesse < 8 then return end
	local data = EffectData()
	data:SetOrigin(ply:GetPos())
	data:SetScale(vitesse / 10)
	util.Effect("onde_choc", data)
end)

Décalcomanies : util.Decal

util.Decal(image, pos, normale, taille, durée, couleur) → booléen projette une image sur les surfaces autour de pos (y compris les props et joueurs qui passent dedans).

• image : "blood" (tache de sang) ou "scorch" (brûlure), intégrées, ou une image de materials/ comme pour Material.
• normale : direction de la surface (vers le haut par défaut ; par exemple tr.HitNormal).
• taille en mètres (0,5 par défaut, de 0,02 à 20), durée en secondes (30 par défaut, de 0,1 à 600 ; elle s'estompe pendant la dernière seconde), couleur = teinte (blanc par défaut).
• Tournée au hasard autour de la normale. 64 au plus : la plus ancienne disparaît.

Forme de GMod : util.Decal(nom, début, fin)

La forme de Garry's Mod marche aussi : util.Decal(nom, début, fin) trace un rayon de début à fin et pose la décalcomanie là où il touche (rien s'il ne touche rien ; le 4e argument, le filtre de GMod, est ignoré). Le jeu reconnaît cette forme quand le 3e argument est un point (pas une direction de longueur 1). Noms de GMod (majuscules indifférentes) : Blood, RedGlowFade, YellowBlood, AlienBlood, Antlion.Splat, Scorch, FadingScorch, SmallScorch, Explosion, BeerSplash, PaintSplatBlue, PaintSplatGreen, PaintSplatPink, PaintSplatOrange, et tous les Impact.* (petite trace d'impact) ; ils marchent aussi dans la forme du jeu.

Côté serveur, util.Decal(nom, début, fin) (cette forme seulement) pose la décalcomanie chez tous les joueurs.

-- Serveur : une tache de sang sous un joueur blessé.
hook.Add("PlayerHurt", "taches", function(ply)
	local pos = ply:GetPos() + Vector(0, 0.5, 0)
	util.Decal("Blood", pos, pos - Vector(0, 2, 0))
end)

-- Impact de balle côté client (reçu par un message net).
net.Receive("impact", function()
	local pos = net.ReadVector()
	local normale = net.ReadVector()
	local data = EffectData()
	data:SetOrigin(pos)
	data:SetNormal(normale)
	data:SetScale(0.6)
	util.Effect("Sparks", data)
	util.Decal("scorch", pos, normale, 0.15, 20)
end)

Effets d'écran

Les fonctions render.* ci-dessous restent actives jusqu'à ce qu'on les change ; pour les fonctions de GMod appelées à chaque image (DrawColorModify, DrawBloom…), voir plus bas. Ils passent sous le HUD (le HUD et les fenêtres Lua restent nets) et sont retirés quand les scripts sont rechargés.

-- Gris et flou quand la santé est basse, flash rouge quand on est touché.
local derniere = 100
hook.Add("Think", "EffetsSante", function()
	local hp = LocalPlayer():Health()
	if hp < derniere then
		render.ScreenFade(Color(200, 0, 0, 120), 0.4)
	end
	derniere = hp
	if hp < 30 and LocalPlayer():Alive() then
		render.SetColorModify({ saturation = 0.3, contrast = 1.1 })
		render.SetBlur(1.5)
	else
		render.SetColorModify()
		render.SetBlur(0)
	end
end)

Effets d'écran de l'image : RenderScreenspaceEffects

Les fonctions de post-traitement de GMod, à appeler à chaque image dans le hook RenderScreenspaceEffects : elles sont remises à zéro avant le hook, et un effet qui n'est plus appelé disparaît à l'image suivante. Elles passent aussi sous le HUD.

-- Vision nocturne : vert, lumineux, avec un halo sur les lumières.
local actif = false
concommand.Add("vision_nuit", function() actif = not actif end)

hook.Add("RenderScreenspaceEffects", "vision_nuit", function()
	if not actif then return end
	DrawColorModify({
		["$pp_colour_brightness"] = 0.1, ["$pp_colour_contrast"] = 1.4, ["$pp_colour_colour"] = 0,
		["$pp_colour_addr"] = 0, ["$pp_colour_addg"] = 0.15, ["$pp_colour_addb"] = 0,
		["$pp_colour_mulr"] = 0, ["$pp_colour_mulg"] = 0, ["$pp_colour_mulb"] = 0,
	})
	DrawBloom(0.6, 1.5, 6, 6, 1, 1, 0.4, 1, 0.4)
end)

Lumières dynamiques et projecteurs

DynamicLight(id)

Une lumière ponctuelle temporaire (tir, explosion, torche), côté client. DynamicLight(id) renvoie la table de la lumière id (un nombre ou un texte ; la crée au premier appel, sinon renvoie la même) ; on règle ses champs, et le jeu la place à chaque image tant que dietime n'est pas passé :

Les noms en majuscules de GMod (Pos, Brightness, Size, DieTime) sont lus aussi ; decay est accepté mais ignoré (la lumière ne faiblit pas). 32 lumières allumées au plus, sans ombres. Pour une lumière fixée à une pièce d'un modèle (phares, gyrophares), voir ents.CreateClientLight.

-- Client : éclair orange de 0,1 s à chaque tir du joueur local.
hook.Add("EntityFireBullets", "eclair_tir", function(tireur, balle)
	if CLIENT and tireur == LocalPlayer() then
		local l = DynamicLight("tir")          -- toujours la même lumière, ravivée à chaque tir
		l.pos = tireur:EyePos() + tireur:GetAimVector() * 1
		l.r, l.g, l.b = 255, 170, 60
		l.brightness = 3
		l.size = 6
		l.dietime = CurTime() + 0.1
	end
end)

ProjectedTexture()

Un projecteur (lampe torche, projecteur de diapositives) : une lumière en cône qui peut projeter une image. ProjectedTexture() renvoie l'objet (16 au plus ; au-delà, une erreur et nil). Il reste invisible tant que Update() n'a pas été appelé, et les changements de position et d'angles ne s'appliquent qu'à l'appel suivant de Update().

-- Une lampe frontale qui suit la vue du joueur local.
local lampe = ProjectedTexture()
lampe:SetFOV(50)
lampe:SetFarZ(30)
lampe:SetBrightness(4)
lampe:SetColor(Color(255, 240, 220))
hook.Add("Think", "lampe", function()
	if not IsValid(lampe) then return end
	local ply = LocalPlayer()
	lampe:SetPos(ply:EyePos())
	lampe:SetAngles(ply:EyeAngles())
	lampe:Update()
end)

Modèles côté client : ClientsideModel

ClientsideModel(id) → modèle ou nil affiche un modèle (id comme pour ents.SpawnProp : "builtin:crate_small", "addon:<clé>/models/x.glb", "gadget:…") que seul ce joueur voit : pas de collision, pas de physique, pas de réseau. Il apparaît à l'origine (0, 0, 0). 128 au plus ; tous sont supprimés quand les scripts sont rechargés. Renvoie nil si l'id est inconnu.

Un modèle client marche avec halo.Add et avec IsValid(modele). Pour un aperçu dans une fenêtre, voir aussi DModelPanel.

-- Chapeau sur la tête du joueur local, visible seulement par lui (aperçu de boutique).
local chapeau
function ApercuChapeau() -- appelée par exemple par un bouton d'une fenêtre vgui
	if IsValid(chapeau) then chapeau:Remove() end
	chapeau = ClientsideModel("builtin:cylinder")
	if not chapeau then return end
	chapeau:SetModelScale(0.5)
	chapeau:SetColor(Color(40, 40, 40))
	chapeau:SetPos(LocalPlayer():GetPos() + Vector(0, 1.95, 0))
	chapeau:SetParent(LocalPlayer())
end

Matériaux créés en Lua : CreateMaterial

Côté client, CreateMaterial(nom, shader, paramètres) crée un matériau (256 au plus) et renvoie son objet ; Material(nom) le retrouve ensuite. Le shader "UnlitGeneric" est dessiné sans lumière, les autres ("VertexLitGeneric"…) avec. Paramètres reconnus :

Méthodes : mat:SetTexture(param, valeur), SetVector, SetFloat, SetInt, SetString (changent un paramètre et refont le matériau), GetTexture(param), GetVector, GetFloat, GetInt, GetString, GetName(), GetShader(), Width(), Height(), IsError(), Recompute(). Il s'utilise avec surface.SetMaterial, et sur un prop : côté serveur, ent:SetMaterial("!nom") envoie le nom à tous, et chaque joueur y met son propre matériau de ce nom (créé par le Lua client ; tant qu'il n'existe pas, le prop garde son matériau d'origine).

Render targets : caméras et écrans

Côté client, GetRenderTarget(nom, largeur, hauteur) (aussi GetRenderTargetEx, mêmes trois premiers arguments) crée une texture dans laquelle une caméra dessine la scène (16 au plus, de 16 à 2048 px ; le même nom redonne la même). Pour la remplir : render.PushRenderTarget(rt), render.RenderView({ origin, angles, fov, znear, zfar }), render.PopRenderTarget(). L'image est rendue à la fin de l'image en cours, une fois par appel : rappelle RenderView (par exemple dans Think) pour une image animée. RenderView ne dessine que dans une render target poussée (pas directement à l'écran). Aussi render.SetRenderTarget(rt), render.GetRenderTarget() ; render.Clear(…) existe et ne fait rien (la caméra redessine toute la texture). Objet : GetName(), Width(), Height(), IsError().

-- Client : un écran de surveillance sur un prop (le serveur a fait ecran:SetMaterial("!camera_ecran")).
local rt = GetRenderTarget("camera_rt", 512, 288)
CreateMaterial("camera_ecran", "UnlitGeneric", { ["$basetexture"] = rt })

hook.Add("Think", "camera", function()
	render.PushRenderTarget(rt)
	render.RenderView({ origin = Vector(0, 6, -10), angles = Angle(-20, 0, 0), fov = 70 })
	render.PopRenderTarget()
end)

Limites

• 3D2D : rendu dans une texture, résolution fixe, zone −512…512 px, 16 panneaux, invisible de dos.
• ToScreen ne teste pas les murs.
• Halos : contour net (pas de flou), petites coupures possibles aux coins des caisses.
• Effets d'écran : sous le HUD ; render.ScreenFade / SetColorModify / SetBlur persistants, Draw* de GMod à rappeler chaque image dans RenderScreenspaceEffects (DrawMotionBlur et DrawTexturize approchés).
• render.Draw* de débogage : seulement pour l'image en cours, depuis PostDrawOpaqueRenderables.
• Dessin 3D (faisceaux, sprites, mesh, particules) : affiché une image plus tard, 120 000 sommets par image, non éclairé, pas de matrices ; stencils limités à ce dessin.
• ParticleEmitter : 1 024 particules par émetteur, 4 096 en tout ; EFFECT : 256 actifs, supprimés seulement quand Think renvoie false.
• DynamicLight : 32 à la fois, sans ombres ; ProjectedTexture : 16.