异步计算管线与实时着色器编译引擎（整合降级策略）
// ==UserScript==
// @name 2D跨域优化系统 - HyperGPU Pro版
// @namespace http://tampermonkey.net/
// @version 3.1.0
// @description 异步计算管线与实时着色器编译引擎（整合降级策略）
// @author KiwiFruit
// @match *://*/*
// @grant none
// @license MIT
// @require https://cdnjs.cloudflare.com/ajax/libs/threads.js/2.7.0/threads.min.js
// @require https://cdnjs.cloudflare.com/ajax/libs/queue.js/2.1.2/queue.min.js
// ==/UserScript==
(function() {
'use strict';
// ███████╗ ██████╗ ███████╗███████╗██████╗ ██╗ ██████╗
// ██╔════╝██╔═══██╗██╔════╝██╔════╝██╔══██╗██║██╔════╝
// █████╗ ██║ ██║███████╗█████╗ ██████╔╝██║██║
// ██╔══╝ ██║ ██║╚════██║██╔══╝ ██╔══██╗██║██║
// ███████╗╚██████╔╝███████║███████╗██████╔╝██║╚██████╗
// ╚══════╝ ╚═════╝ ╚══════╝╚══════╝╚═════╝ ╚═╝ ╚═════╝
// 增强型智能缓存系统（整合LRU+多维优先级）
/* global WorkerPool,GPUProfiler,PriorityQueue,Queue,DataLoader,TextureCompressor,PerformanceMonitor */
class SmartCache extends Map {
constructor(maxSize = 1024 * 1024 * 256, // 256MB
maxEntries = 512,
config = {}) {
super();
this.maxSize = maxSize;
this.maxEntries = maxEntries;
this.priorityWeights = {
frequency: 0.4,
recency: 0.3,
size: 0.2,
distance: 0.1,
criticality: 0.2
};
this.stats = new Map();
this.cleanupInterval = setInterval(() => this.cleanup(), 300000);
}
updateStats(id) {
const now = Date.now();
const stats = this.stats.get(id) || {
count: 1,
lastAccess: now,
size: 0,
position: 0
};
stats.count++;
stats.lastAccess = now;
this.stats.set(id, stats);
}
calculatePriority(id, resource) {
const stats = this.stats.get(id);
const freqWeight = Math.log(stats.count + 1);
const timeWeight = Math.exp(-(Date.now() - stats.lastAccess) / 60000);
const sizeWeight = 1 - (stats.size / this.maxSize);
const distWeight = 1 - (Math.abs(stats.position - resource.position) / 1000);
return (
freqWeight * this.priorityWeights.frequency +
timeWeight * this.priorityWeights.recency +
sizeWeight * this.priorityWeights.size +
distWeight * this.priorityWeights.distance
);
}
evictIfFull() {
if (this.size >= this.maxEntries) {
const candidates = Array.from(this.entries())
.map(([id, value]) => ({
id,
priority: this.calculatePriority(id, value)
}))
.sort((a, b) => a.priority - b.priority);
// 移除优先级最低的20%
candidates.slice(0, Math.ceil(this.maxEntries * 0.2))
.forEach(candidate => this.delete(candidate.id));
}
}
set(id, value) {
this.updateStats(id);
super.set(id, value);
this.evictIfFull();
}
get(id) {
this.updateStats(id);
return super.get(id);
}
cleanup() {
// 清理过期资源（1小时未访问）
const now = Date.now();
for (const [id, stats] of this.stats.entries()) {
if (now - stats.lastAccess > 3600000) {
this.delete(id);
this.stats.delete(id);
}
}
}
}
// ███████╗ ██████╗ ███████╗██████╗ ███████╗██████╗
// ██╔════╝██╔═══██╗██╔════╝██╔══██╗██╔════╝██╔══██╗
// █████╗ ██║ ██║█████╗ ██████╔╝█████╗ ██████╔╝
// ██╔══╝ ██║ ██║██╔══╝ ██╔══██╗██╔══╝ ██╔══██╗
// ██║ ██║██║ ██║███████╗██████╔╝███████╗██║ ██║
// ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝╚═════╝ ╚══════╝╚═╝ ╚═╝
// 增强型任务调度器（支持WebGL降级）
class TaskScheduler {
constructor(maxWorkers = navigator.hardwareConcurrency - 1) {
this.gpuSupported = false;
this.gpuDevice = null;
this.fallbackMode = 'webgl';
this.workerPool = new WorkerPool(maxWorkers);
this.gpuProfiler = new GPUProfiler();
this.priorityQueue = new PriorityQueue();
}
async initGPU() {
if (!navigator.gpu) {
this.fallbackMode = 'webgl';
return false;
}
try {
const adapter = await navigator.gpu.requestAdapter();
this.gpuDevice = await adapter.requestDevice();
this.gpuSupported = true;
return true;
} catch (error) {
console.warn('WebGPU初始化失败，降级到WebGL');
this.fallbackMode = 'webgl';
return false;
}
}
async executeGPU(task) {
if (!this.gpuSupported) return this.fallbackCPU(task);
const commandEncoder = this.gpuDevice.createCommandEncoder();
const passEncoder = commandEncoder.beginComputePass();
passEncoder.dispatchWorkgroups(
task.workgroups.x,
task.workgroups.y,
task.workgroups.z
);
passEncoder.end();
this.gpuDevice.queue.submit([commandEncoder.finish()]);
return { type: 'gpu', result: 'COMPLETED' };
}
async fallbackWebGL(task) {
if (!this.glContext) {
this.glContext = initWebGLContext();
}
const computeShader = this.glContext.createShader(this.glContext.COMPUTE_SHADER);
this.glContext.shaderSource(computeShader, task.shaderCode);
this.glContext.compileShader(computeShader);
if (!this.glContext.getShaderParameter(computeShader, this.glContext.COMPILE_STATUS)) {
console.error('WebGL计算着色器编译失败:', this.glContext.getShaderInfoLog(computeShader));
return this.fallbackCPU(task);
}
const program = this.glContext.createProgram();
this.glContext.attachShader(program, computeShader);
this.glContext.linkProgram(program);
this.glContext.useProgram(program);
this.glContext.bindBufferBase(
this.glContext.SHADER_STORAGE_BUFFER,
0,
task.buffer
);
this.glContext.dispatchCompute(
task.workgroups.x,
task.workgroups.y,
task.workgroups.z
);
this.glContext.memoryBarrier(this.glContext.ALL_BARRIER_BITS);
return { type: 'webgl', result: 'COMPLETED' };
}
async enqueueTask(task, priority = 'normal') {
// 实现优先级队列逻辑
this.priorityQueue.add(task, priority);
const nextTask = this.priorityQueue.getNext();
try {
if (nextTask.gpuRequired && this.gpuSupported) {
return await this.executeGPU(nextTask);
}
return await this.fallbackWebGL(nextTask);
} catch (error) {
console.error('任务执行失败:', error);
return this.fallbackCPU(nextTask);
}
}
}
// █████╗ ██████╗ ███████╗██████╗ ███████╗██████╗
// ██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔════╝██╔══██╗
// ███████║██████╔╝█████╗ ██████╔╝█████╗ ██████╔╝
// ██╔══██║██╔══██╗██╔══╝ ██╔══██╗██╔══╝ ██╔══██╗
// ██║ ██║██║ ██║███████╗██████╔╝███████╗██║ ██║
// ╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝╚═════╝ ╚══════╝╚═╝ ╚═╝
// 增强型着色器编译器（支持AOT优化）
class ShaderCompiler {
constructor() {
this.cache = new Map();
this.worker = new Worker('shader_compiler_worker.js');
this.worker.onmessage = this.handleMessage.bind(this);
this.optimizeQueue = new Queue({ concurrency: 2 });
}
async compile(source, options = {}) {
const hash = this.generateHash(source);
if (this.cache.has(hash)) {
this.cache.get(hash).usageCount++;
return this.cache.get(hash).binary;
}
try {
const result = await this.compileInternal(source, options);
this.cache.set(hash, {
binary: result,
usageCount: 1,
timestamp: Date.now()
});
this.optimizeQueue.defer(() => this.optimizeShader(source));
return result;
} catch (error) {
return this.handleCompilationError(source, error);
}
}
async compileInternal(source, options) {
return new Promise((resolve, reject) => {
this.worker.postMessage({
type: 'compile',
source,
options,
timestamp: Date.now()
});
this.worker.onmessage = (event) => {
if (event.data.error) {
reject(event.data.error);
} else {
resolve(event.data.binary);
}
};
});
}
async optimizeShader(source) {
const profile = this.analyzeUsage(source);
const optimized = this.applyOptimizations(source, profile);
if (optimized !== source) {
await this.compile(optimized, { optimized: true });
}
}
analyzeUsage(source) {
return {
textureAccess: this.countTextureAccesses(source),
uniformUsage: this.countUniforms(source),
arithmetic: this.countOperations(source)
};
}
applyOptimizations(source, profile) {
let optimized = source;
if (profile.textureAccess > 1000) {
optimized = this.optimizeTextureSampling(optimized);
}
if (profile.uniformUsage > 20) {
optimized = this.flattenUniforms(optimized);
}
return optimized;
}
}
// ███████╗██╗ ██╗██████╗ ███████╗██╗ ███████╗
// ██╔════╝╚██╗██╔╝██╔══██╗██╔════╝██║ ██╔════╝
// █████╗ ╚███╔╝ ██████╔╝█████╗ ██║ █████╗
// ██╔══╝ ██╔██╗ ██╔══██╗██╔══╝ ██║ ██╔══╝
// ███████╗██╔╝ ██╗██║ ██║███████╗███████╗███████╗
// ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝╚══════╝╚══════╝
// 增强型资源加载器（支持纹理压缩）
class ResourceLoader {
constructor(cache) {
this.cache = cache;
this.loader = new DataLoader();
this.compression = new TextureCompressor();
}
async loadTexture(url) {
if (this.cache.has(url)) {
return this.cache.get(url);
}
const texture = await this.loader.load(url);
const optimized = this.applyOptimizations(texture);
this.cache.set(url, optimized);
return optimized;
}
applyOptimizations(texture) {
const mips = this.generateMipmaps(texture);
const format = this.selectCompressionFormat(texture);
return this.convertFormat(texture, format, mips);
}
selectCompressionFormat(texture) {
if (!this.glContext) {
this.glContext = initWebGLContext();
}
if (this.glContext.getExtension('EXT_texture_compression_s3tc')) {
return this.glContext.COMPRESSED_RGBA_S3TC_DXT1_EXT;
}
return this.glContext.RGBA;
}
generateMipmaps(texture) {
// 实现mipmap生成逻辑
return texture;
}
convertFormat(texture, format, mips) {
// 实现格式转换逻辑
return texture;
}
}
// ███████╗██████╗ ██████╗ ██████╗ ███████╗
// ██╔════╝██╔══██╗██╔══██╗██╔════╝ ██╔════╝
// █████╗ ██████╔╝██████╔╝██║ ███╗█████╗
// ██╔══╝ ██╔══██╗██╔══██╗██║ ██║██╔══╝
// ███████╗██║ ██║██║ ██║╚██████╔╝███████╗
// ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚══════╝
// WebGL上下文初始化
function initWebGLContext() {
const canvas = document.createElement('canvas');
canvas.style.cssText = `
position: fixed;
top: 0;
left: 0;
width: 1px;
height: 1px;
z-index: -1;
pointer-events: none;
`;
document.body.appendChild(canvas);
const gl = canvas.getContext('webgl2', {
antialias: false,
powerPreference: 'high-performance',
preserveDrawingBuffer: false
});
if (!gl) {
throw new Error('WebGL2不支持');
}
return gl;
}
// ███████╗ ██████╗ ██████╗ ██╗ ██████╗ ██████╗ ██╗ ██╗
// ██╔════╝██╔═══██╗██╔══██╗██║██╔════╝ ██╔══██╗╚██╗ ██╔╝
// █████╗ ██║ ██║██████╔╝██║██║ ███╗██████╔╝ ╚████╔╝
// ██╔══╝ ██║ ██║██╔══██╗██║██║ ██║██╔══██╗ ╚██╔╝
// ███████╗╚██████╔╝██║ ██║██║╚██████╔╝██║ ██║ ██║
// ╚══════╝ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝
// 主系统初始化
async function initSystem() {
const cache = new SmartCache();
const scheduler = new TaskScheduler();
const shaderCompiler = new ShaderCompiler();
const resourceLoader = new ResourceLoader(cache);
// 初始化GPU/WebGL上下文
await scheduler.initGPU();
// 启动性能监控
const monitor = new PerformanceMonitor();
monitor.startVisualizer();
// 预加载核心资源
await resourceLoader.loadAll([
'core_math',
'default_shader',
'texture_packer'
]);
// 返回系统实例
return {
cache,
scheduler,
shaderCompiler,
resourceLoader,
monitor
};
}
// 启动系统
(async () => {
try {
const system = await initSystem();
// 设置事件监听
window.addEventListener('resize', () => {
system.scheduler.enqueueTask({
type: 'resize',
data: { width: window.innerWidth, height: window.innerHeight }
}, 'high');
});
// 主循环
function animate() {
requestAnimationFrame(animate);
system.monitor.updateMetrics();
// 添加渲染逻辑...
}
animate();
} catch (error) {
console.error('系统初始化失败:', error);
}
})();
})();