Skip to content

Projected textures

Jump to bottom
Blixibon edited this page Jun 23, 2020 · 11 revisions

Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.

Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.

They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.

env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.

Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.

Shader changes

Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.

Before:

After:

The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.

The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.

By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.

Other new options

Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:

KeyValues

  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.

Inputs

  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.

env_global_light

TODO

  • Something Index
    • Something special
    • Something else

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Projected textures · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Projected textures
Jump to bottom

Blixibon edited this page Jun 23, 2020
·
11 revisions
Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.
Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.
They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.
env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.
Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.
Shader changes
Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.
Before:
After:
The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.
The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.
By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.
Other new options
Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:
KeyValues
  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.
Inputs
  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.
env_global_light
TODO
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Projected textures · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Projected textures
Jump to bottom

Blixibon edited this page Jun 23, 2020
·
11 revisions
Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.
Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.
They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.
env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.
Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.
Shader changes
Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.
Before:
After:
The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.
The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.
By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.
Other new options
Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:
KeyValues
  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.
Inputs
  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.
env_global_light
TODO
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Projected textures · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Projected textures
Jump to bottom

Blixibon edited this page Jun 23, 2020
·
11 revisions
Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.
Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.
They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.
env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.
Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.
Shader changes
Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.
Before:
After:
The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.
The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.
By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.
Other new options
Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:
KeyValues
  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.
Inputs
  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.
env_global_light
TODO
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Projected textures · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Projected textures
Jump to bottom

Blixibon edited this page Jun 23, 2020
·
11 revisions
Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.
Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.
They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.
env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.
Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.
Shader changes
Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.
Before:
After:
The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.
The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.
By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.
Other new options
Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:
KeyValues
  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.
Inputs
  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.
env_global_light
TODO
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Projected textures · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Projected textures
Jump to bottom

Blixibon edited this page Jun 23, 2020
·
11 revisions
Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.
Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.
They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.
env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.
Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.
Shader changes
Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.
Before:
After:
The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.
The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.
By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.
Other new options
Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:
KeyValues
  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.
Inputs
  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.
env_global_light
TODO
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Projected textures · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Projected textures
Jump to bottom

Blixibon edited this page Jun 23, 2020
·
11 revisions
Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.
Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.
They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.
env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.
Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.
Shader changes
Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.
Before:
After:
The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.
The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.
By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.
Other new options
Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:
KeyValues
  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.
Inputs
  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.
env_global_light
TODO
  • Something Index
    • Something special
    • Something else
Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Projected textures · mapbase-source/source-sdk-2013 Wiki · GitHub
Skip to content
Projected textures
Jump to bottom

Blixibon edited this page Jun 23, 2020
·
11 revisions
Projected textures are basically dynamic lights which can cast dynamic shadows. Mappers can place their own projected textures via the env_projectedtexture entity. Click here for more information on projected textures in Source.
Mapbase's projected textures are made from tons of custom code gathered from the Alien Swarm SDK and open-source projects all over the Source community.
They were first created using Insolence's implementation of Alien Swarm projected textures, which in turn has improvements from City 17: Episode One's projected textures, G-String's projected textures, and the VDC fixes. From this, Mapbase adds its own improvements, like texture clipping fixes or Constant/Linear/Quadratic attenuation control.
env_projectedtexture in Mapbase uses a lot of new I/O/KV. Instead of automatically updating when parented, there is now an "Always Update" spawnflag for control over whether the projected texture updates. However, projected textures made before Mapbase (detected by checking a static keyvalue) will still use the VDC fix for automatically updating when there's a parent. This means Mapbase's projected textures are fully compatible with maps that preclude Mapbase.
Mapbase raises the number of shadow depth textures to 5, meaning you could safely use up to 4 projected textures at any time. However, you could use the -numshadowtextures launch parameter before starting the game to set the shadow map limit yourself. This is based on the Gmod launch parameter of the same name.
Shader changes
Mapbase uses shader code from the aforementioned projects, including Alien Swarm, G-String, City 17: Episode One, etc. The shader changes alone fix most of the bugs the VDC fixes couldn't fix, including the "reverse projection" bug and the bug with decals not receiving casted shadows. These shader changes also use a new shadow calculation method which makes shadows appear much sharper.
Before:
After:
The changes also fix a long-standing bug with Source 2013 projected textures that calculates the attenuation with the player's view, rather than the light's origin. This is very noticeable in the comparison pictures below.
The projected textures in the following pictures have had their brightness scaled by 5 to make them more visible.
By default, Mapbase uses a shadow map resolution of 2048 with a filter size of 0.5. This can be changed in imaterialsystem.h. See this section on the Valve Developer Community for more information.
Other new options
Even though the vast majority of these changes come from other projects, Mapbase still has its own changes that help with env_projectedtexture itself. Here's some new I/O/KV that were not ported from other projects and are not known to exist elsewhere:
KeyValues
  • Constant<float> - The light's constant attenuation, giving the light no falloff. (This value is internally corrected with x*0.5)
  • Linear<float> - The light's linear attenuation, giving the light linear decline. This is the most common attenuation for projected textures. (This value is internally corrected with x*100)
  • Quadratic<float> - The light's quadratic attenuation, giving the light exponentially decreasing falloff. (This value is internally corrected with x*10000)
  • Shadow Atten<float> - The attenuation of the shadows, or how much the shadows should fade into the light of the projected texture, if at all. The player's flashlight uses 0.35 by default, although higher values may be needed for a visible effect.
  • Always Draw<bool> - Forces the projected texture to always draw, regardless of whether the player can see its frustum. This is for projected textures that can be seen on monitors or are in the skybox.
  • Don't follow target<bool> - Prevents the projected texture from actually following its target, if it has one. Intended to be used with "Light Only Target" so it only lights the target without actually following it.
Inputs
  • AlwaysDrawOn/Off<void> - Toggles the "Always Draw" keyvalue.
  • SetConstant<float> - Sets the constant attenuation.
  • SetLinear<float> - Sets the linear attenuation.
  • SetQuadratic<float> - Sets the quadratic attenuation.
  • SetShadowAtten<float> - Sets the shadow attenuation.
env_global_light
TODO
  • Something Index
    • Something special
    • Something else
Clone this wiki locally