mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-16 18:54:45 +00:00
Compare commits
6
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
bc8116006c | ||
|
|
bf9492dffb | ||
|
|
69aed42b89 | ||
|
|
ffe54f61b9 | ||
|
|
c86e1de9f6 | ||
|
|
6af401c834 |
No files matched your search
@@ -2,7 +2,8 @@
|
||||
# Builds the libTracyClient shared library for the tracy-client module.
|
||||
set -euo pipefail
|
||||
|
||||
TRACY_VERSION="${TRACY_VERSION:-v0.13.1}"
|
||||
TRACY_VERSION="${TRACY_VERSION:-v0.14.0}"
|
||||
TRACY_VERSION_BARE="${TRACY_VERSION#v}"
|
||||
OUT_DIR="${OUT_DIR:-dist/tracy-natives}"
|
||||
TRACY_REPO="https://github.com/wolfpld/tracy"
|
||||
|
||||
@@ -16,7 +17,7 @@ case "$(uname -m)" in
|
||||
arm64|aarch64) PLAT_ARCH="arm64" ;;
|
||||
*) PLAT_ARCH="x64" ;;
|
||||
esac
|
||||
RES_DIR="${RES_DIR:-$REPO_ROOT/tracy-client/src/main/resources/natives/tracy/$PLAT_OS-$PLAT_ARCH}"
|
||||
RES_DIR="${RES_DIR:-$REPO_ROOT/tracy-client/src/main/resources/natives/tracy/$TRACY_VERSION_BARE/$PLAT_OS-$PLAT_ARCH}"
|
||||
|
||||
WORK_DIR="$(mktemp -d)"
|
||||
trap 'rm -rf "$WORK_DIR"' EXIT
|
||||
@@ -33,7 +34,8 @@ fi
|
||||
BUILD_DIR="$WORK_DIR/build"
|
||||
export MACOSX_DEPLOYMENT_TARGET="${MACOSX_DEPLOYMENT_TARGET:-11.0}"
|
||||
|
||||
cmake -S "$SRC_DIR" -B "$BUILD_DIR" \
|
||||
cmake -S "$REPO_ROOT/tracy-client/src/main/native" -B "$BUILD_DIR" \
|
||||
-DTRACY_SRC_DIR="$SRC_DIR" \
|
||||
-DCMAKE_BUILD_TYPE=Release \
|
||||
-DBUILD_SHARED_LIBS=ON \
|
||||
-DTRACY_STATIC=OFF \
|
||||
|
||||
@@ -6,10 +6,6 @@ on:
|
||||
- "tracy-v*"
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
tracy-version:
|
||||
description: Tracy git tag to build
|
||||
required: false
|
||||
default: v0.13.1
|
||||
publish:
|
||||
description: Publish angelica-tracy.jar to the GTNH maven
|
||||
type: boolean
|
||||
@@ -20,25 +16,25 @@ jobs:
|
||||
build:
|
||||
strategy:
|
||||
matrix:
|
||||
platform: [linux-x64, windows-x64, macos-x64, macos-arm64]
|
||||
include:
|
||||
- os: ubuntu-22.04
|
||||
platform: linux-x64
|
||||
- os: windows-2025
|
||||
platform: windows-x64
|
||||
- os: macos-15-intel
|
||||
platform: macos-x64
|
||||
- os: macos-15
|
||||
platform: macos-arm64
|
||||
- platform: linux-x64
|
||||
os: ubuntu-22.04
|
||||
- platform: windows-x64
|
||||
os: windows-2025
|
||||
- platform: macos-x64
|
||||
os: macos-15-intel
|
||||
- platform: macos-arm64
|
||||
os: macos-15
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- uses: actions/checkout@v5
|
||||
- name: Build libTracyClient
|
||||
shell: bash
|
||||
env:
|
||||
RAW_VERSION: ${{ github.ref_type == 'tag' && github.ref_name || inputs.tracy-version }}
|
||||
OUT_DIR: dist/tracy-natives
|
||||
run: |
|
||||
export TRACY_VERSION="${RAW_VERSION#tracy-}"
|
||||
export TRACY_VERSION="v$(sed -nE 's/^tracy = "(.*)"$/\1/p' gradle/libs.versions.toml)"
|
||||
bash .github/scripts/build-tracy-natives.sh
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
@@ -56,14 +52,6 @@ jobs:
|
||||
distribution: temurin
|
||||
java-version: 21
|
||||
- uses: gradle/actions/setup-gradle@v4
|
||||
- name: Check tracy version matches the version catalog
|
||||
shell: bash
|
||||
env:
|
||||
RAW_VERSION: ${{ github.ref_type == 'tag' && github.ref_name || inputs.tracy-version }}
|
||||
run: |
|
||||
ver="${RAW_VERSION#tracy-}"
|
||||
grep -q "^tracy = \"${ver#v}\"$" gradle/libs.versions.toml \
|
||||
|| { echo "libs.versions.toml tracy does not match $ver" >&2; exit 1; }
|
||||
- uses: actions/download-artifact@v5
|
||||
with:
|
||||
pattern: tracy-natives-*
|
||||
@@ -71,8 +59,9 @@ jobs:
|
||||
- name: Stage natives into tracy-client resources
|
||||
shell: bash
|
||||
run: |
|
||||
version="$(sed -nE 's/^tracy = "(.*)"$/\1/p' gradle/libs.versions.toml)"
|
||||
for d in staging/tracy-natives-*; do
|
||||
dest="tracy-client/src/main/resources/natives/tracy/${d#staging/tracy-natives-}"
|
||||
dest="tracy-client/src/main/resources/natives/tracy/$version/${d#staging/tracy-natives-}"
|
||||
mkdir -p "$dest"
|
||||
cp "$d"/* "$dest/"
|
||||
done
|
||||
|
||||
@@ -43,3 +43,5 @@ tracy-client/src/main/resources/natives/
|
||||
tracy-client/angelica/
|
||||
dist/tracy-natives/
|
||||
*.tracy
|
||||
|
||||
tracy-client/angelica/
|
||||
@@ -52,8 +52,8 @@ configurations.configureEach {
|
||||
}
|
||||
|
||||
DependencyHandlerScope.of(dependencies).apply {
|
||||
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.7.166:dev")
|
||||
runtimeOnlyNonPublishable("com.github.GTNewHorizons:Hodgepodge:2.7.166:dev")
|
||||
compileOnly("com.github.GTNewHorizons:Hodgepodge:2.7.187:dev")
|
||||
runtimeOnlyNonPublishable("com.github.GTNewHorizons:Hodgepodge:2.7.187:dev")
|
||||
|
||||
runtimeOnlyNonPublishable(rfg.deobf("curse.maven:biomes-o-plenty-220318:2499612"))
|
||||
|
||||
@@ -202,6 +202,7 @@ afterEvaluate {
|
||||
|
||||
glsmTestFixtures(testFixtures(project(":glsm")) as ModuleDependency) { isTransitive = false }
|
||||
testCompileOnly(testFixtures(project(":glsm")))
|
||||
testImplementation("mega:fluidlogged-mc1.7.10:0.1.2")
|
||||
|
||||
testRuntimeOnly(libs.fastutil)
|
||||
testRuntimeOnly(libs.joml)
|
||||
|
||||
@@ -14,6 +14,7 @@ import com.gtnewhorizons.angelica.glsm.backend.VSyncMode;
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
|
||||
import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
|
||||
import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
|
||||
import com.gtnewhorizons.angelica.glsm.ffp.VertexKey;
|
||||
import com.gtnewhorizons.angelica.glsm.hooks.DeferredAlphaHandler;
|
||||
import com.gtnewhorizons.angelica.glsm.hooks.DeferredBlendHandler;
|
||||
import com.gtnewhorizons.angelica.glsm.hooks.DeferredDepthColorHandler;
|
||||
@@ -169,9 +170,6 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
static GLContextState enterWorkerContext() {
|
||||
final GLContextState existing = tlWorkerContext.get();
|
||||
if (existing != null) return existing;
|
||||
|
||||
final GLContextState st = new GLContextState();
|
||||
tlWorkerContext.set(st);
|
||||
synchronized (GLStateManager.class) {
|
||||
@@ -3060,9 +3058,15 @@ public class GLStateManager {
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (light >= VertexKey.FFP_LIGHT_COUNT && (warnedFfpLightMask & (1 << light)) == 0 && ShaderManager.getInstance().isEnabled()) {
|
||||
warnedFfpLightMask |= (1 << light);
|
||||
LOGGER.warn("GL_LIGHT{} enabled, but FFP shader emulation implements only GL_LIGHT0..{}", light, VertexKey.FFP_LIGHT_COUNT - 1, new Throwable("call site"));
|
||||
}
|
||||
ctx().lightStates[light].enable();
|
||||
}
|
||||
|
||||
private static int warnedFfpLightMask = 0;
|
||||
|
||||
public static void enableColorMaterial() {
|
||||
final RecordMode mode = DisplayListManager.getRecordMode();
|
||||
if (mode != RecordMode.NONE) {
|
||||
@@ -3341,6 +3345,11 @@ public class GLStateManager {
|
||||
}
|
||||
CurrentThread = Thread.currentThread();
|
||||
|
||||
if (!splashComplete && CurrentThread != MainThread && !autoVaoBound.get()) {
|
||||
autoVaoBound.set(Boolean.TRUE);
|
||||
glBindVertexArray(glGenVertexArrays());
|
||||
}
|
||||
|
||||
if (splashComplete) return;
|
||||
|
||||
if (drawableGL == null) {
|
||||
@@ -3357,21 +3366,13 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
if (drawableGL != null && drawable == drawableGL) {
|
||||
exitWorkerContext();
|
||||
// Switching TO DrawableGL - enable caching for this thread
|
||||
drawableGLHolder = CurrentThread;
|
||||
} else {
|
||||
enterWorkerContext();
|
||||
if (drawableGLHolder == CurrentThread) {
|
||||
// This thread held DrawableGL but is switching AWAY - disable caching
|
||||
drawableGLHolder = null;
|
||||
}
|
||||
}
|
||||
|
||||
if (CurrentThread != MainThread && !autoVaoBound.get()) {
|
||||
autoVaoBound.set(Boolean.TRUE);
|
||||
glBindVertexArray(glGenVertexArrays());
|
||||
} else if (drawableGLHolder == CurrentThread) {
|
||||
// This thread held DrawableGL but is switching AWAY - disable caching
|
||||
drawableGLHolder = null;
|
||||
}
|
||||
// else: Thread switching to non-DrawableGL, wasn't holder - no change needed
|
||||
}
|
||||
|
||||
public static void releaseContext(Drawable drawable) throws LWJGLException {
|
||||
@@ -3379,7 +3380,6 @@ public class GLStateManager {
|
||||
if (!handled) {
|
||||
drawable.releaseContext();
|
||||
}
|
||||
exitWorkerContext();
|
||||
if (drawableGLHolder == Thread.currentThread()) {
|
||||
drawableGLHolder = null;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
package com.gtnewhorizons.angelica.glsm.ffp;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.LightState;
|
||||
import com.gtnewhorizons.angelica.glsm.states.MaterialState;
|
||||
import org.joml.Matrix3f;
|
||||
import org.joml.Vector3f;
|
||||
import org.joml.Vector4f;
|
||||
|
||||
public final class FFPVertexLighting {
|
||||
|
||||
private static final Vector3f scratchNormal = new Vector3f();
|
||||
private static final Vector3f scratchLightVec = new Vector3f();
|
||||
private static final Vector4f scratchEyePos = new Vector4f();
|
||||
private static final Matrix3f scratchNormalMat = new Matrix3f();
|
||||
private static final Vector3f scratchVec = new Vector3f();
|
||||
|
||||
private FFPVertexLighting() {}
|
||||
|
||||
public static boolean modulatesVertexColor(Vector3f destFactor) {
|
||||
destFactor.set(1.0f);
|
||||
|
||||
if (!GLStateManager.getLightingState().isEnabled()) return false;
|
||||
if (!GLStateManager.getColorMaterial().isEnabled()) return false;
|
||||
if (VertexKey.encodeColorMaterialMode(GLStateManager.getColorMaterialParameter().getValue()) != VertexKey.CM_AMBIENT_AND_DIFFUSE) return false;
|
||||
|
||||
final MaterialState material = GLStateManager.getFrontMaterial();
|
||||
if (material.emission.x != 0.0f || material.emission.y != 0.0f || material.emission.z != 0.0f)
|
||||
return false;
|
||||
|
||||
final boolean materialHasSpecular = material.shininess > 0.0f && (material.specular.x != 0.0f || material.specular.y != 0.0f || material.specular.z != 0.0f);
|
||||
|
||||
final Vector4f lightModelAmbient = GLStateManager.getLightModel().ambient;
|
||||
float r = lightModelAmbient.x;
|
||||
float g = lightModelAmbient.y;
|
||||
float b = lightModelAmbient.z;
|
||||
|
||||
final var lightEnables = GLStateManager.getLightStates();
|
||||
final var lightData = GLStateManager.getLightDataStates();
|
||||
boolean normalReady = false;
|
||||
|
||||
for (int i = 0; i < VertexKey.FFP_LIGHT_COUNT; i++) {
|
||||
if (!lightEnables[i].isEnabled()) continue;
|
||||
final LightState light = lightData[i];
|
||||
if (materialHasSpecular && (light.specular.x != 0.0f || light.specular.y != 0.0f || light.specular.z != 0.0f))
|
||||
return false;
|
||||
if (!normalReady) {
|
||||
transformCurrentNormal();
|
||||
normalReady = true;
|
||||
}
|
||||
final float nDotVP = Math.max(scratchNormal.dot(lightDirection(light)), 0.0f);
|
||||
r += light.ambient.x + nDotVP * light.diffuse.x;
|
||||
g += light.ambient.y + nDotVP * light.diffuse.y;
|
||||
b += light.ambient.z + nDotVP * light.diffuse.z;
|
||||
}
|
||||
|
||||
if (r == 1.0f && g == 1.0f && b == 1.0f) return false;
|
||||
if (!Float.isFinite(r + g + b)) return false;
|
||||
destFactor.set(r, g, b);
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void transformCurrentNormal() {
|
||||
GLStateManager.getModelViewMatrix().normal(scratchNormalMat);
|
||||
scratchNormal.set(ShaderManager.getCurrentNormal());
|
||||
scratchNormalMat.transform(scratchNormal);
|
||||
if (GLStateManager.getNormalizeState().isEnabled()) {
|
||||
scratchNormal.normalize();
|
||||
} else if (GLStateManager.getRescaleNormalState().isEnabled()) {
|
||||
scratchNormal.mul(Uniforms.rescaleFactor(scratchNormalMat, scratchVec));
|
||||
}
|
||||
}
|
||||
|
||||
private static Vector3f lightDirection(LightState light) {
|
||||
if (light.position.w == 0.0f) {
|
||||
scratchLightVec.set(light.position.x, light.position.y, light.position.z);
|
||||
} else {
|
||||
scratchEyePos.set(0.0f, 0.0f, 0.0f, 1.0f).mul(GLStateManager.getModelViewMatrix());
|
||||
scratchLightVec.set(light.position.x - scratchEyePos.x, light.position.y - scratchEyePos.y, light.position.z - scratchEyePos.z);
|
||||
}
|
||||
return scratchLightVec.normalize();
|
||||
}
|
||||
}
|
||||
@@ -232,8 +232,12 @@ public class Uniforms {
|
||||
private void stageNormalMatrix() {
|
||||
GLStateManager.getModelViewMatrix().normal(normalMatrix);
|
||||
putMat3(FFPUniformBlock.NORMAL_MATRIX, normalMatrix);
|
||||
final float scale = 1.0f / normalMatrix.getColumn(0, tempVec3).length();
|
||||
putFloat(FFPUniformBlock.NORMAL_SCALE, scale);
|
||||
putFloat(FFPUniformBlock.NORMAL_SCALE, rescaleFactor(normalMatrix, tempVec3));
|
||||
}
|
||||
|
||||
static float rescaleFactor(Matrix3f normalMatrix, Vector3f scratch) {
|
||||
final float f = normalMatrix.getColumn(2, scratch).lengthSquared();
|
||||
return f > 1.0e-12f ? 1.0f / (float) Math.sqrt(f) : 1.0f;
|
||||
}
|
||||
|
||||
private void stageTextureMatrices() {
|
||||
|
||||
@@ -20,38 +20,36 @@ public final class VertexKey {
|
||||
|
||||
public static final int MAX_UNITS = 4;
|
||||
|
||||
public static final int FFP_LIGHT_COUNT = 2;
|
||||
|
||||
private final long packed;
|
||||
|
||||
private static final int BIT_LIGHTING = 0;
|
||||
private static final int BIT_LIGHT0 = 1;
|
||||
private static final int BIT_LIGHT1 = 2;
|
||||
private static final int BIT_LIGHT0_DIR = 3;
|
||||
private static final int BIT_LIGHT1_DIR = 4;
|
||||
private static final int BIT_COLOR_MATERIAL = 5;
|
||||
private static final int BIT_SEPARATE_SPECULAR = 6;
|
||||
private static final int BIT_FOG = 7;
|
||||
private static final int BIT_FOG_DIST_MODE = 8; // 2 bits: 8-9
|
||||
private static final int BIT_NORMALIZE = 10;
|
||||
private static final int BIT_RESCALE_NORMAL = 11;
|
||||
// Per-unit texcoord enable: bits 12-15 (unit 0..3). Unit 1 doubles as the lightmap flag.
|
||||
private static final int BIT_UNIT_TEX_BASE = 12;
|
||||
private static final int BIT_HAS_VERTEX_COLOR = 16;
|
||||
private static final int BIT_HAS_VERTEX_NORMAL = 17;
|
||||
private static final int BIT_HAS_VERTEX_TEX = 18;
|
||||
private static final int BIT_HAS_VERTEX_LIGHTMAP = 19;
|
||||
private static final int BIT_COLOR_MAT_MODE = 20; // 3 bits: 20-22
|
||||
// TexGen modes (unit 0 only, for now): 3 bits each (0=NONE, 1=OBJ_LINEAR, 2=EYE_LINEAR).
|
||||
private static final int BIT_TEXGEN_S = 23; // 3 bits: 23-25
|
||||
private static final int BIT_TEXGEN_T = 26; // 3 bits: 26-28
|
||||
private static final int BIT_TEXGEN_R = 29; // 3 bits: 29-31
|
||||
private static final int BIT_TEXGEN_Q = 32; // 3 bits: 32-34
|
||||
private static final int BIT_CLIP_PLANES = 35;
|
||||
private static final int BIT_WIDE_LINE = 36;
|
||||
// Per-unit texmat enable: bits 37-40 (unit 0..3). Unit 1 is the lightmap matrix.
|
||||
private static final int BIT_UNIT_TEXMAT_BASE = 37;
|
||||
private static final int BIT_UNIT23_UV_FROM_UNIT0 = 41;
|
||||
private static final int BIT_LINE_STIPPLE = 42;
|
||||
private static final int BIT_INSTANCED = 44;
|
||||
private static final int BIT_LIGHT_BASE = BIT_LIGHTING + 1;
|
||||
private static final int BIT_LIGHT_DIR_BASE = BIT_LIGHT_BASE + FFP_LIGHT_COUNT;
|
||||
private static final int BIT_COLOR_MATERIAL = BIT_LIGHT_DIR_BASE + FFP_LIGHT_COUNT;
|
||||
private static final int BIT_SEPARATE_SPECULAR = BIT_COLOR_MATERIAL + 1;
|
||||
private static final int BIT_FOG = BIT_SEPARATE_SPECULAR + 1;
|
||||
private static final int BIT_FOG_DIST_MODE = BIT_FOG + 1;
|
||||
private static final int BIT_NORMALIZE = BIT_FOG_DIST_MODE + 2;
|
||||
private static final int BIT_RESCALE_NORMAL = BIT_NORMALIZE + 1;
|
||||
private static final int BIT_UNIT_TEX_BASE = BIT_RESCALE_NORMAL + 1;
|
||||
private static final int BIT_HAS_VERTEX_COLOR = BIT_UNIT_TEX_BASE + MAX_UNITS;
|
||||
private static final int BIT_HAS_VERTEX_NORMAL = BIT_HAS_VERTEX_COLOR + 1;
|
||||
private static final int BIT_HAS_VERTEX_TEX = BIT_HAS_VERTEX_NORMAL + 1;
|
||||
private static final int BIT_HAS_VERTEX_LIGHTMAP = BIT_HAS_VERTEX_TEX + 1;
|
||||
private static final int BIT_COLOR_MAT_MODE = BIT_HAS_VERTEX_LIGHTMAP + 1;
|
||||
// TexGen modes are unit 0 only, for now.
|
||||
private static final int BIT_TEXGEN_S = BIT_COLOR_MAT_MODE + 3;
|
||||
private static final int BIT_TEXGEN_T = BIT_TEXGEN_S + 3;
|
||||
private static final int BIT_TEXGEN_R = BIT_TEXGEN_T + 3;
|
||||
private static final int BIT_TEXGEN_Q = BIT_TEXGEN_R + 3;
|
||||
private static final int BIT_CLIP_PLANES = BIT_TEXGEN_Q + 3;
|
||||
private static final int BIT_WIDE_LINE = BIT_CLIP_PLANES + 1;
|
||||
private static final int BIT_UNIT_TEXMAT_BASE = BIT_WIDE_LINE + 1;
|
||||
private static final int BIT_UNIT23_UV_FROM_UNIT0 = BIT_UNIT_TEXMAT_BASE + MAX_UNITS;
|
||||
private static final int BIT_LINE_STIPPLE = BIT_UNIT23_UV_FROM_UNIT0 + 1;
|
||||
private static final int BIT_INSTANCED = BIT_LINE_STIPPLE + 1;
|
||||
|
||||
public static final int TG_NONE = 0;
|
||||
public static final int TG_OBJ_LINEAR = 1;
|
||||
@@ -70,10 +68,8 @@ public final class VertexKey {
|
||||
public long pack() { return packed; }
|
||||
|
||||
public boolean lightingEnabled() { return bit(BIT_LIGHTING); }
|
||||
public boolean light0Enabled() { return bit(BIT_LIGHT0); }
|
||||
public boolean light1Enabled() { return bit(BIT_LIGHT1); }
|
||||
public boolean light0Directional() { return bit(BIT_LIGHT0_DIR); }
|
||||
public boolean light1Directional() { return bit(BIT_LIGHT1_DIR); }
|
||||
public boolean lightEnabled(int light) { return bit(BIT_LIGHT_BASE + light); }
|
||||
public boolean lightDirectional(int light) { return bit(BIT_LIGHT_DIR_BASE + light); }
|
||||
public boolean colorMaterialEnabled() { return bit(BIT_COLOR_MATERIAL); }
|
||||
public boolean separateSpecular() { return bit(BIT_SEPARATE_SPECULAR); }
|
||||
public boolean fogEnabled() { return bit(BIT_FOG); }
|
||||
@@ -136,17 +132,12 @@ public final class VertexKey {
|
||||
if (lighting) {
|
||||
bits |= (1L << BIT_LIGHTING);
|
||||
|
||||
if (GLStateManager.getLightStates()[0].isEnabled()) {
|
||||
bits |= (1L << BIT_LIGHT0);
|
||||
for (int i = 0; i < FFP_LIGHT_COUNT; i++) {
|
||||
if (!GLStateManager.getLightStates()[i].isEnabled()) continue;
|
||||
bits |= (1L << (BIT_LIGHT_BASE + i));
|
||||
// position.w == 0 means directional
|
||||
if (GLStateManager.getLightDataStates()[0].position.w == 0.0f) {
|
||||
bits |= (1L << BIT_LIGHT0_DIR);
|
||||
}
|
||||
}
|
||||
if (GLStateManager.getLightStates()[1].isEnabled()) {
|
||||
bits |= (1L << BIT_LIGHT1);
|
||||
if (GLStateManager.getLightDataStates()[1].position.w == 0.0f) {
|
||||
bits |= (1L << BIT_LIGHT1_DIR);
|
||||
if (GLStateManager.getLightDataStates()[i].position.w == 0.0f) {
|
||||
bits |= (1L << (BIT_LIGHT_DIR_BASE + i));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -265,7 +256,7 @@ public final class VertexKey {
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("FFPVertexKey[0x%011X: lit=%b l0=%b l1=%b cm=%b fog=%b tex=%d%d%d%d texmat=%d%d%d%d col=%b nrm=%b vtex=%b vlm=%b tg=%d/%d/%d/%d clip=%b wline=%b inst=%b]",
|
||||
packed, lightingEnabled(), light0Enabled(), light1Enabled(),
|
||||
packed, lightingEnabled(), lightEnabled(0), lightEnabled(1),
|
||||
colorMaterialEnabled(), fogEnabled(),
|
||||
unitTexCoordEnabled(0)?1:0, unitTexCoordEnabled(1)?1:0, unitTexCoordEnabled(2)?1:0, unitTexCoordEnabled(3)?1:0,
|
||||
unitTexMatEnabled(0)?1:0, unitTexMatEnabled(1)?1:0, unitTexMatEnabled(2)?1:0, unitTexMatEnabled(3)?1:0,
|
||||
|
||||
@@ -182,11 +182,10 @@ public final class VertexShaderGenerator {
|
||||
}
|
||||
|
||||
// Per-light accumulation
|
||||
if (key.light0Enabled()) {
|
||||
emitLightContribution(sb, key, 0);
|
||||
}
|
||||
if (key.light1Enabled()) {
|
||||
emitLightContribution(sb, key, 1);
|
||||
for (int i = 0; i < VertexKey.FFP_LIGHT_COUNT; i++) {
|
||||
if (key.lightEnabled(i)) {
|
||||
emitLightContribution(sb, key, i);
|
||||
}
|
||||
}
|
||||
|
||||
sb.append(" v_Color = vec4(clamp(color0, 0.0, 1.0), outAlpha);\n");
|
||||
@@ -198,7 +197,7 @@ public final class VertexShaderGenerator {
|
||||
|
||||
private static void emitLightContribution(StringBuilder sb, VertexKey key, int lightIndex) {
|
||||
final String li = String.valueOf(lightIndex);
|
||||
final boolean directional = (lightIndex == 0) ? key.light0Directional() : key.light1Directional();
|
||||
final boolean directional = key.lightDirectional(lightIndex);
|
||||
final String posUniform = "u_Light" + li + "Position";
|
||||
|
||||
sb.append(" { // Light ").append(li).append('\n');
|
||||
|
||||
@@ -0,0 +1,92 @@
|
||||
package com.gtnewhorizons.angelica.glsm.profiling;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public final class SectionRegistry {
|
||||
|
||||
public interface Emitter {
|
||||
long enter(int category, String text);
|
||||
void leave(long nativeId);
|
||||
void setup(int category, String name);
|
||||
boolean isConnected();
|
||||
}
|
||||
|
||||
private static final class Category {
|
||||
final int id;
|
||||
final String name;
|
||||
|
||||
Category(int id, String name) {
|
||||
this.id = id;
|
||||
this.name = name;
|
||||
}
|
||||
}
|
||||
|
||||
private static final class Section {
|
||||
final long token;
|
||||
final int category;
|
||||
final String text;
|
||||
long nativeId;
|
||||
|
||||
Section(long token, int category, String text, long nativeId) {
|
||||
this.token = token;
|
||||
this.category = category;
|
||||
this.text = text;
|
||||
this.nativeId = nativeId;
|
||||
}
|
||||
}
|
||||
|
||||
private final Emitter emitter;
|
||||
private final List<Category> categories = new ArrayList<>();
|
||||
private final List<Section> open = new ArrayList<>();
|
||||
private long nextToken;
|
||||
private boolean connected;
|
||||
|
||||
public SectionRegistry(Emitter emitter) {
|
||||
this.emitter = emitter;
|
||||
}
|
||||
|
||||
public synchronized void registerCategory(int category, String name) {
|
||||
categories.add(new Category(category, name));
|
||||
}
|
||||
|
||||
public synchronized long enter(int category, String text) {
|
||||
syncConnection();
|
||||
final long token = ++nextToken;
|
||||
open.add(new Section(token, category, text, emitter.enter(category, text)));
|
||||
return token;
|
||||
}
|
||||
|
||||
public synchronized void leave(long token) {
|
||||
for (int i = 0; i < open.size(); i++) {
|
||||
final Section section = open.get(i);
|
||||
if (section.token == token) {
|
||||
open.remove(i);
|
||||
if (section.nativeId != 0L) emitter.leave(section.nativeId);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public synchronized void poll() {
|
||||
syncConnection();
|
||||
}
|
||||
|
||||
private void syncConnection() {
|
||||
final boolean now = emitter.isConnected();
|
||||
if (now == connected) return;
|
||||
connected = now;
|
||||
if (now) replay();
|
||||
}
|
||||
|
||||
private void replay() {
|
||||
for (int i = 0; i < categories.size(); i++) {
|
||||
final Category category = categories.get(i);
|
||||
emitter.setup(category.id, category.name);
|
||||
}
|
||||
for (int i = 0; i < open.size(); i++) {
|
||||
final Section section = open.get(i);
|
||||
section.nativeId = emitter.enter(section.category, section.text);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -44,6 +44,18 @@ public final class Tracy {
|
||||
public static final int COLOR_IRIS = 0x9E862E; // gold
|
||||
public static final int COLOR_FFP = 0x7A4E9E; // purple
|
||||
|
||||
public static final int SECTION_WORLD = 1;
|
||||
public static final int SECTION_SHADERS = 2;
|
||||
public static final int SECTION_BENCHMARK = 3;
|
||||
public static final int SECTION_UI = 4;
|
||||
|
||||
private static final SectionRegistry SECTIONS = new SectionRegistry(new SectionRegistry.Emitter() {
|
||||
@Override public long enter(int category, String text) { return BACKEND.sectionEnter(category, text); }
|
||||
@Override public void leave(long nativeId) { BACKEND.sectionLeave(nativeId); }
|
||||
@Override public void setup(int category, String name) { BACKEND.sectionSetup(category, name); }
|
||||
@Override public boolean isConnected() { return BACKEND.isConnected(); }
|
||||
});
|
||||
|
||||
private static final ThreadLocal<ZoneStack> STACK = new ThreadLocal<>() {
|
||||
@Override
|
||||
protected ZoneStack initialValue() {
|
||||
@@ -62,6 +74,10 @@ public final class Tracy {
|
||||
FINE_ZONES = ENABLED && SystemProperties.TRACY_FINE_ZONES;
|
||||
if (ENABLED) {
|
||||
Runtime.getRuntime().addShutdownHook(new Thread(Tracy::shutdown, "Tracy-Shutdown"));
|
||||
SECTIONS.registerCategory(SECTION_WORLD, "World");
|
||||
SECTIONS.registerCategory(SECTION_SHADERS, "Shaders");
|
||||
SECTIONS.registerCategory(SECTION_BENCHMARK, "Benchmark");
|
||||
SECTIONS.registerCategory(SECTION_UI, "UI");
|
||||
LOGGER.info("Tracy profiling enabled");
|
||||
}
|
||||
}
|
||||
@@ -168,7 +184,7 @@ public final class Tracy {
|
||||
final String name = stack.poppedName();
|
||||
if (name != null && WARNED_LEAKS.add(name)) {
|
||||
LOGGER.warn("Tracy: unbalanced profiler section '{}' left open (leaked by its caller); closed at next root", name);
|
||||
BACKEND.message("unbalanced profiler section '" + name + "' closed at root");
|
||||
BACKEND.message("unbalanced profiler section '" + name + "' closed at root", TracyBackend.SEVERITY_WARNING);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -274,6 +290,7 @@ public final class Tracy {
|
||||
threadNameRefreshed = true;
|
||||
BACKEND.setCurrentThreadName(Thread.currentThread().getName());
|
||||
}
|
||||
SECTIONS.poll();
|
||||
BACKEND.frameMark();
|
||||
}
|
||||
|
||||
@@ -330,8 +347,22 @@ public final class Tracy {
|
||||
}
|
||||
|
||||
public static void message(String text) {
|
||||
message(text, TracyBackend.SEVERITY_INFO);
|
||||
}
|
||||
|
||||
public static void message(String text, int severity) {
|
||||
if (!ENABLED || SHUTTING_DOWN || !CaptureGate.markersThisFrame) return;
|
||||
BACKEND.message(text);
|
||||
BACKEND.message(text, severity);
|
||||
}
|
||||
|
||||
public static long sectionEnter(int category, String text) {
|
||||
if (!ENABLED || SHUTTING_DOWN) return 0L;
|
||||
return SECTIONS.enter(category, text);
|
||||
}
|
||||
|
||||
public static void sectionLeave(long token) {
|
||||
if (token == 0L || !ENABLED || SHUTTING_DOWN) return;
|
||||
SECTIONS.leave(token);
|
||||
}
|
||||
|
||||
public static boolean isConnected() {
|
||||
|
||||
@@ -5,6 +5,13 @@ public interface TracyBackend {
|
||||
int PLOT_FORMAT_MEMORY = 1;
|
||||
int PLOT_FORMAT_PERCENTAGE = 2;
|
||||
|
||||
int SEVERITY_TRACE = 0;
|
||||
int SEVERITY_DEBUG = 1;
|
||||
int SEVERITY_INFO = 2;
|
||||
int SEVERITY_WARNING = 3;
|
||||
int SEVERITY_ERROR = 4;
|
||||
int SEVERITY_FATAL = 5;
|
||||
|
||||
boolean init();
|
||||
|
||||
long internSrcLoc(String name, int color);
|
||||
@@ -24,7 +31,14 @@ public interface TracyBackend {
|
||||
|
||||
void plotInt(long namePtr, long value);
|
||||
void plot(long namePtr, double value);
|
||||
void message(String text);
|
||||
|
||||
void message(String text, int severity);
|
||||
default void message(String text) { message(text, SEVERITY_INFO); }
|
||||
|
||||
long sectionEnter(int category, String text);
|
||||
void sectionLeave(long id);
|
||||
void sectionSetup(int category, String name);
|
||||
|
||||
void setCurrentThreadName(String name);
|
||||
boolean isConnected();
|
||||
void shutdown();
|
||||
|
||||
@@ -2,7 +2,7 @@ package com.gtnewhorizons.angelica.glsm.profiling;
|
||||
|
||||
public final class ZoneStack {
|
||||
public static final long EMPTY = -1L;
|
||||
static final int MAX_DEPTH = 512;
|
||||
public static final int MAX_DEPTH = 512;
|
||||
|
||||
private long[] stack = new long[64];
|
||||
private boolean[] gpu = new boolean[64];
|
||||
|
||||
+1
-36
@@ -106,7 +106,7 @@ public class GLSM_ServerSideState_UnitTest {
|
||||
backgroundError = e;
|
||||
} finally {
|
||||
try {
|
||||
GLStateManager.releaseContext(sharedDrawable);
|
||||
sharedDrawable.releaseContext();
|
||||
} catch (LWJGLException e) {
|
||||
// Ignore on cleanup
|
||||
}
|
||||
@@ -342,41 +342,6 @@ public class GLSM_ServerSideState_UnitTest {
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void testDepthStateDoesNotBleedFromSharedDrawable() throws InterruptedException {
|
||||
final boolean originalDepthTest = GLStateManager.getDepthTest().isEnabled();
|
||||
final int originalDepthFunc = GLStateManager.getDepthState().getFunc();
|
||||
final boolean originalDepthMask = GLStateManager.getDepthState().isEnabled();
|
||||
|
||||
try {
|
||||
GLStateManager.enableDepthTest();
|
||||
GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
|
||||
GLStateManager.glDepthMask(true);
|
||||
|
||||
executeOnSharedDrawable(() -> {
|
||||
GLStateManager.disableDepthTest();
|
||||
GLStateManager.glDepthFunc(GL11.GL_ALWAYS);
|
||||
GLStateManager.glDepthMask(false);
|
||||
|
||||
assertFalse(GLStateManager.getDepthTest().isEnabled());
|
||||
assertEquals(GL11.GL_ALWAYS, GLStateManager.getDepthState().getFunc());
|
||||
assertFalse(GLStateManager.getDepthState().isEnabled());
|
||||
});
|
||||
|
||||
assertTrue(GLStateManager.getDepthTest().isEnabled(), "SharedDrawable depth test leaked into the main cache");
|
||||
assertEquals(GL11.GL_LEQUAL, GLStateManager.getDepthState().getFunc(), "SharedDrawable depth func leaked into the main cache");
|
||||
assertTrue(GLStateManager.getDepthState().isEnabled(), "SharedDrawable depth mask leaked into the main cache");
|
||||
} finally {
|
||||
if (originalDepthTest) {
|
||||
GLStateManager.enableDepthTest();
|
||||
} else {
|
||||
GLStateManager.disableDepthTest();
|
||||
}
|
||||
GLStateManager.glDepthFunc(originalDepthFunc);
|
||||
GLStateManager.glDepthMask(originalDepthMask);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test glTexParameterf (float parameters like LOD_BIAS).
|
||||
*/
|
||||
|
||||
@@ -0,0 +1,241 @@
|
||||
package com.gtnewhorizons.angelica.glsm.ffp;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement;
|
||||
import com.gtnewhorizons.angelica.glsm.GLCoreTest;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.joml.Vector3f;
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags.COLOR_BIT;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
@GLCoreTest
|
||||
class FFPVertexLightingGLTest {
|
||||
|
||||
private static final int POSITION_LOC = VertexFormatElement.Usage.POSITION.getAttributeLocation();
|
||||
private static final int COLOR_LOC = VertexFormatElement.Usage.COLOR.getAttributeLocation();
|
||||
private static final int STRIDE = 16;
|
||||
|
||||
private static final int VERTEX_COLOR = 0xFF808080;
|
||||
private static final float VERTEX_CHANNEL = 0x80 / 255.0f;
|
||||
|
||||
private static final Vector3f IDENTITY_FACTOR = new Vector3f(1.0f, 1.0f, 1.0f);
|
||||
|
||||
private final Vector3f factor = new Vector3f();
|
||||
|
||||
private int vao;
|
||||
private int vbo;
|
||||
|
||||
@BeforeEach
|
||||
void setUpState() {
|
||||
GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
|
||||
GLStateManager.glLoadIdentity();
|
||||
GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
GLStateManager.glLoadIdentity();
|
||||
GLStateManager.glViewport(0, 0, 800, 600);
|
||||
GLStateManager.disableDepthTest();
|
||||
GLStateManager.disableCull();
|
||||
GLStateManager.disableBlend();
|
||||
GLStateManager.disableTexture();
|
||||
GLStateManager.glNormal3f(0.0f, 0.0f, 1.0f);
|
||||
standardItemLighting();
|
||||
|
||||
GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_EMISSION, floats(0.0f, 0.0f, 0.0f, 1.0f));
|
||||
GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_SPECULAR, floats(0.0f, 0.0f, 0.0f, 1.0f));
|
||||
GLStateManager.glMaterialf(GL11.GL_FRONT_AND_BACK, GL11.GL_SHININESS, 0.0f);
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
void cleanup() {
|
||||
GLStateManager.glDisable(GL11.GL_NORMALIZE);
|
||||
GLStateManager.glDisable(GL12.GL_RESCALE_NORMAL);
|
||||
GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
GLStateManager.glLoadIdentity();
|
||||
GLStateManager.glDisable(GL11.GL_LIGHTING);
|
||||
GLStateManager.glDisable(GL11.GL_LIGHT0);
|
||||
GLStateManager.glDisable(GL11.GL_LIGHT1);
|
||||
GLStateManager.glDisable(GL11.GL_LIGHT2);
|
||||
GLStateManager.glDisable(GL11.GL_COLOR_MATERIAL);
|
||||
final ShaderManager sm = ShaderManager.getInstance();
|
||||
if (sm.isActive()) sm.deactivate();
|
||||
sm.disable();
|
||||
GLStateManager.glBindVertexArray(0);
|
||||
if (vbo != 0) {
|
||||
GLStateManager.glDeleteBuffers(vbo);
|
||||
vbo = 0;
|
||||
}
|
||||
if (vao != 0) {
|
||||
GLStateManager.glDeleteVertexArrays(vao);
|
||||
vao = 0;
|
||||
}
|
||||
}
|
||||
|
||||
private static void standardItemLighting() {
|
||||
GLStateManager.glEnable(GL11.GL_LIGHTING);
|
||||
GLStateManager.glEnable(GL11.GL_LIGHT0);
|
||||
GLStateManager.glEnable(GL11.GL_LIGHT1);
|
||||
GLStateManager.glEnable(GL11.GL_COLOR_MATERIAL);
|
||||
GLStateManager.glColorMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_AMBIENT_AND_DIFFUSE);
|
||||
GLStateManager.glLightModel(GL11.GL_LIGHT_MODEL_AMBIENT, floats(0.4f, 0.4f, 0.4f, 1.0f));
|
||||
light(GL11.GL_LIGHT0, 0.2f, 1.0f, -0.7f);
|
||||
light(GL11.GL_LIGHT1, -0.2f, 1.0f, 0.7f);
|
||||
}
|
||||
|
||||
private static void light(int light, float x, float y, float z) {
|
||||
GLStateManager.glLight(light, GL11.GL_POSITION, floats(x, y, z, 0.0f));
|
||||
GLStateManager.glLight(light, GL11.GL_DIFFUSE, floats(0.6f, 0.6f, 0.6f, 1.0f));
|
||||
GLStateManager.glLight(light, GL11.GL_AMBIENT, floats(0.0f, 0.0f, 0.0f, 1.0f));
|
||||
GLStateManager.glLight(light, GL11.GL_SPECULAR, floats(0.0f, 0.0f, 0.0f, 1.0f));
|
||||
}
|
||||
|
||||
private static String gateState() {
|
||||
final var material = GLStateManager.getFrontMaterial();
|
||||
return "lighting=" + GLStateManager.getLightingState().isEnabled()
|
||||
+ " colorMaterial=" + GLStateManager.getColorMaterial().isEnabled()
|
||||
+ " cmParam=0x" + Integer.toHexString(GLStateManager.getColorMaterialParameter().getValue())
|
||||
+ " emission=" + material.emission
|
||||
+ " specular=" + material.specular
|
||||
+ " shininess=" + material.shininess
|
||||
+ " lmAmbient=" + GLStateManager.getLightModel().ambient
|
||||
+ " light0=" + GLStateManager.getLightStates()[0].isEnabled()
|
||||
+ " light1=" + GLStateManager.getLightStates()[1].isEnabled();
|
||||
}
|
||||
|
||||
private static FloatBuffer floats(float... values) {
|
||||
final FloatBuffer buf = BufferUtils.createFloatBuffer(values.length);
|
||||
buf.put(values).flip();
|
||||
return buf;
|
||||
}
|
||||
|
||||
private void buildTriangle() {
|
||||
vao = GLStateManager.glGenVertexArrays();
|
||||
GLStateManager.glBindVertexArray(vao);
|
||||
|
||||
final ByteBuffer data = BufferUtils.createByteBuffer(3 * STRIDE);
|
||||
putVertex(data, -0.9f, -0.9f);
|
||||
putVertex(data, 0.9f, -0.9f);
|
||||
putVertex(data, 0.0f, 0.9f);
|
||||
data.flip();
|
||||
|
||||
vbo = GLStateManager.glGenBuffers();
|
||||
GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
|
||||
GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, data, GL15.GL_STATIC_DRAW);
|
||||
GLStateManager.glEnableVertexAttribArray(POSITION_LOC);
|
||||
GLStateManager.glVertexAttribPointer(POSITION_LOC, 3, GL11.GL_FLOAT, false, STRIDE, 0L);
|
||||
GLStateManager.glEnableVertexAttribArray(COLOR_LOC);
|
||||
GLStateManager.glVertexAttribPointer(COLOR_LOC, 4, GL11.GL_UNSIGNED_BYTE, true, STRIDE, 12L);
|
||||
VAOManager.setCurrentVertexFlags(COLOR_BIT);
|
||||
}
|
||||
|
||||
private static void putVertex(ByteBuffer buf, float x, float y) {
|
||||
final int base = buf.position();
|
||||
buf.putFloat(base, x).putFloat(base + 4, y).putFloat(base + 8, 0.0f);
|
||||
buf.putInt(base + 12, VERTEX_COLOR);
|
||||
buf.position(base + STRIDE);
|
||||
}
|
||||
|
||||
private float[] drawAndReadCenter() {
|
||||
buildTriangle();
|
||||
final ShaderManager sm = ShaderManager.getInstance();
|
||||
sm.enable();
|
||||
sm.activate();
|
||||
|
||||
GLStateManager.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
GLStateManager.glClear(GL11.GL_COLOR_BUFFER_BIT);
|
||||
GLStateManager.glDrawArrays(GL11.GL_TRIANGLES, 0, 3);
|
||||
assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "FFP draw must not raise a GL error");
|
||||
|
||||
final ByteBuffer pixel = BufferUtils.createByteBuffer(4);
|
||||
GL11.glReadPixels(400, 200, 1, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixel);
|
||||
return new float[] { (pixel.get(0) & 0xFF) / 255.0f, (pixel.get(1) & 0xFF) / 255.0f, (pixel.get(2) & 0xFF) / 255.0f };
|
||||
}
|
||||
|
||||
private void assertSolverMatchesShader(String context) {
|
||||
assertTrue(FFPVertexLighting.modulatesVertexColor(factor), context + ": expected a representable factor");
|
||||
final float[] actual = drawAndReadCenter();
|
||||
final float[] expected = { Math.min(1.0f, VERTEX_CHANNEL * factor.x), Math.min(1.0f, VERTEX_CHANNEL * factor.y), Math.min(1.0f, VERTEX_CHANNEL * factor.z) };
|
||||
for (int c = 0; c < 3; c++) {
|
||||
assertEquals(expected[c], actual[c], 2.0f / 255.0f, context + ": channel " + c + " solver=" + expected[c] + " shader=" + actual[c] + " factor=" + factor);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void faceOnNormalMatchesGeneratedShader() {
|
||||
GLStateManager.glNormal3f(0.0f, 0.0f, 1.0f);
|
||||
assertSolverMatchesShader("face-on normal");
|
||||
}
|
||||
|
||||
@Test
|
||||
void signNormalMatchesGeneratedShader() {
|
||||
GLStateManager.glNormal3f(0.0f, 0.0f, -0.010416667f);
|
||||
assertSolverMatchesShader("sign normal");
|
||||
assertTrue(factor.x < 0.45f, "a 0.0104-long normal must stay at the 0.4 light model ambient floor rather than pick up 0.6 per light, got " + factor.x);
|
||||
}
|
||||
|
||||
@Test
|
||||
void tiltedNormalMatchesGeneratedShader() {
|
||||
GLStateManager.glNormal3f(0.3f, 0.8f, 0.5f);
|
||||
assertSolverMatchesShader("tilted normal");
|
||||
}
|
||||
|
||||
@Test
|
||||
void rescaleNormalMatchesGeneratedShader() {
|
||||
GLStateManager.glEnable(GL12.GL_RESCALE_NORMAL);
|
||||
GLStateManager.glScalef(1.0f, 2.0f, 1.0f);
|
||||
GLStateManager.glNormal3f(0.0f, 1.0f, 0.0f);
|
||||
assertSolverMatchesShader("rescale normal");
|
||||
}
|
||||
|
||||
@Test
|
||||
void normalizeMatchesGeneratedShader() {
|
||||
GLStateManager.glEnable(GL11.GL_NORMALIZE);
|
||||
GLStateManager.glScalef(1.0f, 2.0f, 1.0f);
|
||||
GLStateManager.glNormal3f(0.0f, 1.0f, 0.0f);
|
||||
assertSolverMatchesShader("normalize");
|
||||
assertTrue(factor.x > 1.2f, "normalize restores the unit normal, which must pick up more diffuse than rescale's 0.5-long one, got " + factor.x);
|
||||
}
|
||||
|
||||
@Test
|
||||
void materialEmissionIsNotRepresentable() {
|
||||
GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_EMISSION, floats(0.1f, 0.1f, 0.1f, 1.0f));
|
||||
assertFalse(FFPVertexLighting.modulatesVertexColor(factor), "emission is additive, so the lit colour is not vertexColor * factor");
|
||||
assertEquals(IDENTITY_FACTOR, factor, "a rejected solve must leave an identity factor");
|
||||
}
|
||||
|
||||
@Test
|
||||
void specularContributionIsNotRepresentable() {
|
||||
GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_SPECULAR, floats(1.0f, 1.0f, 1.0f, 1.0f));
|
||||
GLStateManager.glMaterialf(GL11.GL_FRONT_AND_BACK, GL11.GL_SHININESS, 16.0f);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPECULAR, floats(1.0f, 1.0f, 1.0f, 1.0f));
|
||||
assertFalse(FFPVertexLighting.modulatesVertexColor(factor), "specular is additive, so the lit colour is not vertexColor * factor");
|
||||
}
|
||||
|
||||
@Test
|
||||
void nonAmbientAndDiffuseColorMaterialIsNotRepresentable() {
|
||||
GLStateManager.glColorMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_EMISSION);
|
||||
assertFalse(FFPVertexLighting.modulatesVertexColor(factor), "only AMBIENT_AND_DIFFUSE makes the lit colour scale with the vertex colour");
|
||||
}
|
||||
|
||||
@Test
|
||||
void lightsBeyondTheFfpCountAreIgnored() {
|
||||
assertTrue(FFPVertexLighting.modulatesVertexColor(factor), FFPVertexLightingGLTest::gateState);
|
||||
final Vector3f twoLights = new Vector3f(factor);
|
||||
|
||||
light(GL11.GL_LIGHT2, 0.0f, 0.0f, 1.0f);
|
||||
GLStateManager.glEnable(GL11.GL_LIGHT2);
|
||||
assertTrue(FFPVertexLighting.modulatesVertexColor(factor), FFPVertexLightingGLTest::gateState);
|
||||
|
||||
assertEquals(twoLights, factor, "VertexShaderGenerator emits only GL_LIGHT0/GL_LIGHT1, so text must not see GL_LIGHT2 either");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package com.gtnewhorizons.angelica.glsm.ffp;
|
||||
|
||||
import org.joml.Matrix3f;
|
||||
import org.joml.Matrix4f;
|
||||
import org.joml.Vector3f;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
class UniformsRescaleTest {
|
||||
|
||||
private static float rescaleFactorFor(float sx, float sy, float sz) {
|
||||
final Matrix3f normalMatrix = new Matrix3f();
|
||||
new Matrix4f().rotateY(0.7f).scale(sx, sy, sz).normal(normalMatrix);
|
||||
return Uniforms.rescaleFactor(normalMatrix, new Vector3f());
|
||||
}
|
||||
|
||||
@Test
|
||||
void rescaleFactorUsesTheInverseModelviewBottomRow() {
|
||||
assertEquals(8.0f, rescaleFactorFor(4.0f, 2.0f, 8.0f), 1.0e-5f, "wrong normal matrix column");
|
||||
}
|
||||
|
||||
@Test
|
||||
void uniformScaleIsRowIndependent() {
|
||||
assertEquals(2.0f, rescaleFactorFor(2.0f, 2.0f, 2.0f), 1.0e-5f);
|
||||
}
|
||||
|
||||
@Test
|
||||
void singularMatrixFallsBackToUnitScale() {
|
||||
assertEquals(1.0f, rescaleFactorFor(1.0f, 1.0f, 0.0f), 1.0e-5f, "a degenerate normal matrix must not divide by zero");
|
||||
}
|
||||
}
|
||||
+113
@@ -0,0 +1,113 @@
|
||||
package com.gtnewhorizons.angelica.glsm.profiling;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
class SectionRegistryTest {
|
||||
|
||||
private static final class RecordingEmitter implements SectionRegistry.Emitter {
|
||||
final List<String> setups = new ArrayList<>();
|
||||
final List<String> enters = new ArrayList<>();
|
||||
final List<Long> leaves = new ArrayList<>();
|
||||
long nextId;
|
||||
boolean connected;
|
||||
|
||||
@Override
|
||||
public long enter(int category, String text) {
|
||||
enters.add(category + ":" + text);
|
||||
return connected ? ++nextId : 0L;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void leave(long nativeId) {
|
||||
leaves.add(nativeId);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setup(int category, String name) {
|
||||
setups.add(category + ":" + name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isConnected() {
|
||||
return connected;
|
||||
}
|
||||
}
|
||||
|
||||
private final RecordingEmitter emitter = new RecordingEmitter();
|
||||
private final SectionRegistry registry = new SectionRegistry(emitter);
|
||||
|
||||
private void reconnect() {
|
||||
emitter.connected = false;
|
||||
registry.poll();
|
||||
emitter.connected = true;
|
||||
registry.poll();
|
||||
}
|
||||
|
||||
@Test
|
||||
void tokensOutliveEveryReplayAndLeaveUsesTheNewestId() {
|
||||
final long openedWhileDisconnected = registry.enter(1, "world");
|
||||
assertNotEquals(0L, openedWhileDisconnected, "token must be valid while disconnected");
|
||||
assertEquals(0L, emitter.nextId, "no native id while disconnected");
|
||||
|
||||
emitter.connected = true;
|
||||
registry.poll();
|
||||
final long openedWhileConnected = registry.enter(2, "shaders");
|
||||
assertNotEquals(openedWhileDisconnected, openedWhileConnected);
|
||||
|
||||
reconnect();
|
||||
emitter.leaves.clear();
|
||||
registry.leave(openedWhileDisconnected);
|
||||
registry.leave(openedWhileConnected);
|
||||
|
||||
assertEquals(List.of(3L, 4L), emitter.leaves, "leave must use the post-reconnect ids");
|
||||
}
|
||||
|
||||
@Test
|
||||
void aSectionEnteredOnTheConnectingFrameIsNotEnteredTwice() {
|
||||
emitter.connected = true;
|
||||
registry.enter(2, "shaders pack / Overworld");
|
||||
registry.poll();
|
||||
|
||||
assertEquals(List.of("2:shaders pack / Overworld"), emitter.enters, "must not re-enter a section already live on this connection");
|
||||
}
|
||||
|
||||
@Test
|
||||
void reconnectReplaysEveryCategoryAndEveryOpenSection() {
|
||||
registry.registerCategory(1, "World");
|
||||
registry.registerCategory(4, "UI");
|
||||
emitter.connected = true;
|
||||
registry.poll();
|
||||
registry.enter(1, "world");
|
||||
registry.enter(4, "pause");
|
||||
emitter.setups.clear();
|
||||
emitter.enters.clear();
|
||||
|
||||
reconnect();
|
||||
|
||||
assertEquals(List.of("1:World", "4:UI"), emitter.setups, "all categories re-registered");
|
||||
assertEquals(List.of("1:world", "4:pause"), emitter.enters, "all open sections re-entered");
|
||||
}
|
||||
|
||||
@Test
|
||||
void leftSectionsAreNotResurrectedByAReconnect() {
|
||||
emitter.connected = true;
|
||||
registry.poll();
|
||||
final long token = registry.enter(1, "transient");
|
||||
registry.leave(token);
|
||||
emitter.enters.clear();
|
||||
emitter.leaves.clear();
|
||||
|
||||
reconnect();
|
||||
registry.leave(token);
|
||||
|
||||
assertTrue(emitter.enters.isEmpty(), "closed sections must not be re-entered");
|
||||
assertTrue(emitter.leaves.isEmpty(), "closed tokens must not be left twice");
|
||||
}
|
||||
}
|
||||
@@ -15,7 +15,7 @@ eventbus = "7.0-beta.15"
|
||||
glslTransformLib = "0.2.0-33.g3ec381e"
|
||||
antlr4Runtime = "4.13.2"
|
||||
jcpp = "1.4.14"
|
||||
tracy = "0.13.1"
|
||||
tracy = "0.14.0"
|
||||
retroFuturaBootstrap = "1.1.0"
|
||||
|
||||
lombok = "1.18.46"
|
||||
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
package com.gtnewhorizons.angelica.sdlgpu.shader;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.shader.GlslVulkanPreprocess;
|
||||
import com.gtnewhorizons.angelica.glsm.shader.SpirvCompiler;
|
||||
import com.gtnewhorizons.angelica.glsm.testutil.TestPaths;
|
||||
import com.gtnewhorizons.angelica.sdlgpu.sampler.SamplerLookup;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.util.shaderc.Shaderc;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
import static org.lwjgl.system.MemoryUtil.memFree;
|
||||
|
||||
class FontFilterVertexSamplerTest {
|
||||
|
||||
private static final String FONT_FILTER_VSH = TestPaths.readString("src/main/resources/assets/angelica/shaders/fontFilter.vsh");
|
||||
|
||||
private static String runSdlPipeline(String raw) {
|
||||
final GlslVulkanPreprocess.Result pre = GlslVulkanPreprocess.run(raw, GL20.GL_VERTEX_SHADER, "fontFilter.vsh", true);
|
||||
String src = pre != null ? pre.rewrittenSource() : raw;
|
||||
src = ClipZRemap.injectGLToVulkanClipZ(src);
|
||||
src = SamplerStripper.stripUnused(src);
|
||||
return src;
|
||||
}
|
||||
|
||||
private static ShaderManager.StageReflection reflect(String source) {
|
||||
final SpirvCompiler.Result r = SpirvCompiler.compile(source, Shaderc.shaderc_vertex_shader,
|
||||
"fontFilter.vsh", SpirvCompiler.Options.vulkanForced460Core());
|
||||
assertNotNull(r.spirv(), () -> "fontFilter.vsh failed to compile for Vulkan: " + r.error());
|
||||
final ByteBuffer spirv = r.spirv();
|
||||
try {
|
||||
return ShaderManager.reflectStage(spirv, true);
|
||||
} finally {
|
||||
memFree(spirv);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void samplerSurvivesStrippingAndReflectsOnTheVertexStage() {
|
||||
final String transformed = runSdlPipeline(FONT_FILTER_VSH);
|
||||
assertTrue(transformed.contains("uniform sampler2D lightmap"), "a reference inside a runtime if must keep the declaration; only preprocessor #if hides it");
|
||||
|
||||
final List<String> samplers = reflect(transformed).samplerNames();
|
||||
assertEquals(List.of("lightmap"), samplers, "the vertex stage must expose exactly the lightmap sampler");
|
||||
}
|
||||
|
||||
@Test
|
||||
void looseVec3UniformReflectsWithAStd140Offset() {
|
||||
final List<ShaderManager.UboMember> members = reflect(runSdlPipeline(FONT_FILTER_VSH)).uboMembers();
|
||||
|
||||
final ShaderManager.UboMember lightmap = members.stream()
|
||||
.filter(m -> m.name().endsWith("u_Lightmap"))
|
||||
.findFirst()
|
||||
.orElseThrow(() -> new AssertionError("u_Lightmap missing from the default uniform block: " + members));
|
||||
|
||||
assertEquals(3, lightmap.vectorSize(), "u_Lightmap must reflect as a 3-wide vector");
|
||||
assertEquals(1, lightmap.columns(), "u_Lightmap is a vector, not a matrix");
|
||||
assertEquals(0, lightmap.arrayStride(), "a scalar member takes Std140Writer's contiguous path");
|
||||
assertEquals(0, lightmap.offset() % 16, "std140 aligns a vec3 to 16 bytes");
|
||||
}
|
||||
|
||||
@Test
|
||||
void samplerNamedLightmapResolvesToTextureUnitOne() {
|
||||
final List<String> samplers = reflect(runSdlPipeline(FONT_FILTER_VSH)).samplerNames();
|
||||
final Object2IntOpenHashMap<String> noExplicitUnits = new Object2IntOpenHashMap<>();
|
||||
noExplicitUnits.defaultReturnValue(-1);
|
||||
|
||||
assertEquals(1, SamplerLookup.getSamplerTextureUnit(samplers, noExplicitUnits, 0), "even without a glUniform1i the SDL fallback must put a sampler named 'lightmap' on unit 1");
|
||||
}
|
||||
}
|
||||
@@ -4,19 +4,14 @@ import com.google.common.collect.ImmutableSet;
|
||||
import com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack;
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.vao.IndexBuffer;
|
||||
import com.gtnewhorizon.gtnhlib.util.font.GlyphReplacements;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.FORMATTING_CHAR;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.GRADIENT_PAYLOAD;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.SECTION_X_LENGTH;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.SECTION_X_PAYLOAD;
|
||||
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.config.FontConfig;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.AngelicaMod;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.RenderSystem;
|
||||
import com.gtnewhorizons.angelica.glsm.ffp.FFPVertexLighting;
|
||||
import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.streaming.PersistentStreamingBuffer;
|
||||
import com.gtnewhorizons.angelica.glsm.streaming.StreamingUploader;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.FontRendererAccessor;
|
||||
import com.gtnewhorizons.angelica.rendering.tesr.ModelPartBatcher;
|
||||
import com.gtnewhorizons.angelica.rendering.tesr.TesrBatchRenderer;
|
||||
@@ -29,20 +24,31 @@ import net.minecraft.util.MathHelper;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import org.embeddedt.embeddium.impl.render.shader.ShaderLoader;
|
||||
import org.joml.Matrix4f;
|
||||
import org.joml.Vector3f;
|
||||
import org.joml.Vector4f;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.Objects;
|
||||
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryStack.stackPush;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.*;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress0;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutByte;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutFloat;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutShort;
|
||||
import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memRealloc;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.FORMATTING_CHAR;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.GRADIENT_PAYLOAD;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.SECTION_X_LENGTH;
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.SECTION_X_PAYLOAD;
|
||||
|
||||
/**
|
||||
* A batching replacement for {@code FontRenderer}
|
||||
@@ -67,6 +73,8 @@ public class BatchingFontRenderer {
|
||||
private final int AAStrength;
|
||||
private final int alphaTestRefLocation;
|
||||
private final int mvpMatrixLocation;
|
||||
private final int lightmapLocation;
|
||||
private final int lightmapSamplerLocation;
|
||||
private final int fontShaderId;
|
||||
|
||||
final boolean isSGA;
|
||||
@@ -111,6 +119,8 @@ public class BatchingFontRenderer {
|
||||
AAStrength = GLStateManager.glGetUniformLocation(fontShaderId, "strength");
|
||||
alphaTestRefLocation = GLStateManager.glGetUniformLocation(fontShaderId, "alphaTestRef");
|
||||
mvpMatrixLocation = GLStateManager.glGetUniformLocation(fontShaderId, "u_MVPMatrix");
|
||||
lightmapLocation = GLStateManager.glGetUniformLocation(fontShaderId, "u_Lightmap");
|
||||
lightmapSamplerLocation = GLStateManager.glGetUniformLocation(fontShaderId, "lightmap");
|
||||
if (ebo == null) {
|
||||
ebo = new IndexBuffer();
|
||||
vbo = GLStateManager.glGenBuffers();
|
||||
@@ -128,6 +138,9 @@ public class BatchingFontRenderer {
|
||||
// [v, v, t, t, c, c, c, c, tb, tb, tb, tb]
|
||||
// v, t and tb are floats, c is bytes; 36 bytes total
|
||||
private static final int VERTEX_SIZE = 36;
|
||||
|
||||
/** {@code OpenGlHelper.lightmapTexUnit} */
|
||||
private static final int LIGHTMAP_TEX_UNIT = 1;
|
||||
private static int rawCapacity = INITIAL_BATCH_SIZE * VERTEX_SIZE;
|
||||
private static ByteBuffer vertexData = memAlloc(rawCapacity);
|
||||
private static long vertexDataAddress = memAddress0(vertexData);
|
||||
@@ -138,6 +151,7 @@ public class BatchingFontRenderer {
|
||||
private static int fontVAO = 0;
|
||||
private static int vbo;
|
||||
private static IndexBuffer ebo;
|
||||
private static int lightmapSamplerProgram;
|
||||
|
||||
private static final int RING_CAPACITY = 2 * 1024 * 1024;
|
||||
private static PersistentStreamingBuffer streamRing;
|
||||
@@ -158,11 +172,58 @@ public class BatchingFontRenderer {
|
||||
private int blendSrcRGB = GL11.GL_SRC_ALPHA;
|
||||
private int blendDstRGB = GL11.GL_ONE_MINUS_SRC_ALPHA;
|
||||
|
||||
private float lightmapU = 0.0f;
|
||||
private float lightmapV = 0.0f;
|
||||
private boolean lightmapActive = false;
|
||||
private int lightmapTextureId = 0;
|
||||
|
||||
private final Vector3f lightingFactor = new Vector3f(1.0f, 1.0f, 1.0f);
|
||||
private boolean lightingFactorActive = false;
|
||||
|
||||
private static final Vector4f scratchLightmapUv = new Vector4f();
|
||||
|
||||
private int applyLighting(int argb) {
|
||||
if (!lightingFactorActive) return argb;
|
||||
final int red = Math.max(0, Math.min(255, (int) (((argb >> 16) & 0xFF) * lightingFactor.x + 0.5f)));
|
||||
final int green = Math.max(0, Math.min(255, (int) (((argb >> 8) & 0xFF) * lightingFactor.y + 0.5f)));
|
||||
final int blue = Math.max(0, Math.min(255, (int) ((argb & 0xFF) * lightingFactor.z + 0.5f)));
|
||||
return (argb & 0xFF000000) | (red << 16) | (green << 8) | blue;
|
||||
}
|
||||
|
||||
private void captureLightmapState() {
|
||||
final int unitBinding = GLStateManager.getTextures().getTextureUnitBindings(LIGHTMAP_TEX_UNIT).getBinding();
|
||||
|
||||
final boolean active = GLStateManager.getProjectionMatrix().m33() == 0.0f && unitBinding != 0;
|
||||
|
||||
float u = 0.0f;
|
||||
float v = 0.0f;
|
||||
int texture = 0;
|
||||
if (active) {
|
||||
scratchLightmapUv.set(GLSMConfig.lastBrightnessX, GLSMConfig.lastBrightnessY, 0.0f, 1.0f).mul(GLStateManager.getTextures().getTextureUnitMatrix(LIGHTMAP_TEX_UNIT));
|
||||
u = scratchLightmapUv.x;
|
||||
v = scratchLightmapUv.y;
|
||||
texture = unitBinding;
|
||||
}
|
||||
|
||||
if (active == lightmapActive && u == lightmapU && v == lightmapV && texture == lightmapTextureId) {
|
||||
return;
|
||||
}
|
||||
sealBatchSegment();
|
||||
lightmapActive = active;
|
||||
lightmapU = u;
|
||||
lightmapV = v;
|
||||
lightmapTextureId = texture;
|
||||
}
|
||||
|
||||
private static final class TextSegment {
|
||||
final Matrix4f mvp = new Matrix4f();
|
||||
BatchingFontRenderer owner;
|
||||
int cmdStart;
|
||||
int cmdEnd;
|
||||
float lightmapU;
|
||||
float lightmapV;
|
||||
boolean lightmapActive;
|
||||
int lightmapTexture;
|
||||
}
|
||||
|
||||
// 16-bit EBO index range
|
||||
@@ -183,7 +244,6 @@ public class BatchingFontRenderer {
|
||||
private int batchSealedEnd;
|
||||
private static BatchingFontRenderer arenaOwner;
|
||||
|
||||
|
||||
private void allocateBuffers() {
|
||||
populateEBO(rawCapacity / VERTEX_SIZE);
|
||||
}
|
||||
@@ -255,6 +315,7 @@ public class BatchingFontRenderer {
|
||||
|
||||
private void pushVtx(float x, float y, int rgba, float u, float v, float uMin, float uMax, float vMin, float vMax) {
|
||||
final long ptr = vertexDataAddress + vertexDataPos;
|
||||
rgba = applyLighting(rgba);
|
||||
|
||||
// v, v
|
||||
memPutFloat(ptr, x);
|
||||
@@ -414,6 +475,10 @@ public class BatchingFontRenderer {
|
||||
segment.cmdStart = batchSealedEnd;
|
||||
segment.cmdEnd = end;
|
||||
resolveMvp(segment.mvp);
|
||||
segment.lightmapActive = lightmapActive;
|
||||
segment.lightmapU = lightmapU;
|
||||
segment.lightmapV = lightmapV;
|
||||
segment.lightmapTexture = lightmapTextureId;
|
||||
batchSegments.add(segment);
|
||||
batchSealedEnd = end;
|
||||
}
|
||||
@@ -485,6 +550,7 @@ public class BatchingFontRenderer {
|
||||
final boolean isTextureEnabledBefore = GLStateManager.glIsEnabled(GL11.GL_TEXTURE_2D);
|
||||
final boolean isBlendEnabledBefore = GLStateManager.glIsEnabled(GL11.GL_BLEND);
|
||||
final int boundTextureBefore = GLStateManager.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
final int lightmapBindingBefore = boundLightmapTexture();
|
||||
|
||||
final boolean depthTestBefore = GLStateManager.getDepthTest().isEnabled();
|
||||
final boolean depthMaskBefore = GLStateManager.getDepthState().isEnabled();
|
||||
@@ -493,6 +559,7 @@ public class BatchingFontRenderer {
|
||||
GLStateManager.glDepthMask(false);
|
||||
flushLastTexture = DUMMY_RESOURCE_LOCATION;
|
||||
flushTextureChanged = false;
|
||||
resetFlushLightmap();
|
||||
try (MemoryStack stack = stackPush()) {
|
||||
final FloatBuffer mvpBuf = stack.mallocFloat(16);
|
||||
for (int i = 0, n = deferredSegments.size(); i < n; i++) {
|
||||
@@ -500,10 +567,12 @@ public class BatchingFontRenderer {
|
||||
mvpBuf.clear();
|
||||
segment.mvp.get(mvpBuf);
|
||||
GLStateManager.glUniformMatrix4(segment.owner.mvpMatrixLocation, false, mvpBuf);
|
||||
uploadLightmap(segment.owner.lightmapLocation, segment.lightmapActive, segment.lightmapU,
|
||||
segment.lightmapV, segment.lightmapTexture);
|
||||
drawCommands(segment.owner.batchCommands.elements(), segment.cmdStart, segment.cmdEnd, segment.owner);
|
||||
}
|
||||
}
|
||||
restoreFontDrawState(prevProgram, isTextureEnabledBefore, isBlendEnabledBefore, boundTextureBefore);
|
||||
restoreFontDrawState(prevProgram, isTextureEnabledBefore, isBlendEnabledBefore, boundTextureBefore, lightmapBindingBefore);
|
||||
restoreDepth(depthTestBefore, depthMaskBefore);
|
||||
|
||||
discardDeferredText();
|
||||
@@ -517,6 +586,7 @@ public class BatchingFontRenderer {
|
||||
segment.owner.recycleBatchSegments();
|
||||
segment.owner.batchSealedEnd = 0;
|
||||
segment.owner.batchMatrixValid = false;
|
||||
segment.owner.resetLightmapState();
|
||||
segment.owner = null;
|
||||
}
|
||||
deferredSegmentPool.addAll(deferredSegments);
|
||||
@@ -578,12 +648,14 @@ public class BatchingFontRenderer {
|
||||
final boolean isTextureEnabledBefore = GLStateManager.glIsEnabled(GL11.GL_TEXTURE_2D);
|
||||
final boolean isBlendEnabledBefore = GLStateManager.glIsEnabled(GL11.GL_BLEND);
|
||||
final int boundTextureBefore = GLStateManager.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
|
||||
final int lightmapBindingBefore = boundLightmapTexture();
|
||||
final boolean depthTestBefore = GLStateManager.getDepthTest().isEnabled();
|
||||
final boolean depthMaskBefore = GLStateManager.getDepthState().isEnabled();
|
||||
|
||||
setupFontDrawState();
|
||||
flushLastTexture = DUMMY_RESOURCE_LOCATION;
|
||||
flushTextureChanged = false;
|
||||
resetFlushLightmap();
|
||||
try (MemoryStack stack = stackPush()) {
|
||||
final FloatBuffer mvpBuf = stack.mallocFloat(16);
|
||||
for (int i = 0; i < segmentCount; i++) {
|
||||
@@ -591,6 +663,7 @@ public class BatchingFontRenderer {
|
||||
mvpBuf.clear();
|
||||
segment.mvp.get(mvpBuf);
|
||||
GLStateManager.glUniformMatrix4(mvpMatrixLocation, false, mvpBuf);
|
||||
uploadLightmap(lightmapLocation, segment.lightmapActive, segment.lightmapU, segment.lightmapV, segment.lightmapTexture);
|
||||
drawCommands(cmds, segment.cmdStart, segment.cmdEnd, this);
|
||||
}
|
||||
if (batchSealedEnd < cmdCount) {
|
||||
@@ -598,10 +671,11 @@ public class BatchingFontRenderer {
|
||||
resolveMvp(scratchMvp);
|
||||
scratchMvp.get(mvpBuf);
|
||||
GLStateManager.glUniformMatrix4(mvpMatrixLocation, false, mvpBuf);
|
||||
uploadLightmap(lightmapLocation, lightmapActive, lightmapU, lightmapV, lightmapTextureId);
|
||||
drawCommands(cmds, batchSealedEnd, cmdCount, this);
|
||||
}
|
||||
}
|
||||
restoreFontDrawState(prevProgram, isTextureEnabledBefore, isBlendEnabledBefore, boundTextureBefore);
|
||||
restoreFontDrawState(prevProgram, isTextureEnabledBefore, isBlendEnabledBefore, boundTextureBefore, lightmapBindingBefore);
|
||||
restoreDepth(depthTestBefore, depthMaskBefore);
|
||||
|
||||
truncateBatchToWatermark();
|
||||
@@ -624,6 +698,10 @@ public class BatchingFontRenderer {
|
||||
GLStateManager.glUniform1f(AAStrength, FontConfig.fontAAStrength / 120.f);
|
||||
}
|
||||
GLStateManager.glUniform1f(alphaTestRefLocation, GLStateManager.getAlphaState().getReference());
|
||||
if (lightmapSamplerProgram != fontShaderId) {
|
||||
GLStateManager.glUniform1i(lightmapSamplerLocation, LIGHTMAP_TEX_UNIT);
|
||||
lightmapSamplerProgram = fontShaderId;
|
||||
}
|
||||
|
||||
if (fontVAO == 0) {
|
||||
fontVAO = GLStateManager.glGenVertexArrays();
|
||||
@@ -654,6 +732,38 @@ public class BatchingFontRenderer {
|
||||
private static ResourceLocation flushLastTexture;
|
||||
private static boolean flushTextureChanged;
|
||||
|
||||
private static float flushLastLightmapU;
|
||||
private static float flushLastLightmapV;
|
||||
private static boolean flushLastLightmapActive;
|
||||
|
||||
private static void resetFlushLightmap() {
|
||||
flushLastLightmapU = Float.NaN;
|
||||
flushLastLightmapV = Float.NaN;
|
||||
flushLastLightmapActive = false;
|
||||
}
|
||||
|
||||
private static int boundLightmapTexture() {
|
||||
return GLStateManager.getTextures().getTextureUnitBindings(LIGHTMAP_TEX_UNIT).getBinding();
|
||||
}
|
||||
|
||||
private static void bindLightmapTexture(int texture) {
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + LIGHTMAP_TEX_UNIT);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
}
|
||||
|
||||
private static void uploadLightmap(int uniformLocation, boolean active, float u, float v, int texture) {
|
||||
if (u != flushLastLightmapU || v != flushLastLightmapV || active != flushLastLightmapActive) {
|
||||
GLStateManager.glUniform3f(uniformLocation, u, v, active ? 1.0f : 0.0f);
|
||||
flushLastLightmapU = u;
|
||||
flushLastLightmapV = v;
|
||||
flushLastLightmapActive = active;
|
||||
}
|
||||
if (active && texture != 0 && boundLightmapTexture() != texture) {
|
||||
bindLightmapTexture(texture);
|
||||
}
|
||||
}
|
||||
|
||||
private static void drawCommands(FontDrawCmd[] cmdsData, int from, int to, BatchingFontRenderer owner) {
|
||||
for (int i = from; i < to; i++) {
|
||||
final FontDrawCmd cmd = cmdsData[i];
|
||||
@@ -673,7 +783,7 @@ public class BatchingFontRenderer {
|
||||
}
|
||||
}
|
||||
|
||||
private static void restoreFontDrawState(int prevProgram, boolean textureEnabledBefore, boolean blendEnabledBefore, int boundTextureBefore) {
|
||||
private static void restoreFontDrawState(int prevProgram, boolean textureEnabledBefore, boolean blendEnabledBefore, int boundTextureBefore, int lightmapBindingBefore) {
|
||||
GLStateManager.glUseProgram(prevProgram);
|
||||
|
||||
GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
|
||||
@@ -688,6 +798,9 @@ public class BatchingFontRenderer {
|
||||
if (flushTextureChanged) {
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, boundTextureBefore);
|
||||
}
|
||||
if (boundLightmapTexture() != lightmapBindingBefore) {
|
||||
bindLightmapTexture(lightmapBindingBefore);
|
||||
}
|
||||
}
|
||||
|
||||
private static void restoreDepth(boolean testBefore, boolean maskBefore) {
|
||||
@@ -709,11 +822,19 @@ public class BatchingFontRenderer {
|
||||
batchMatrixValid = false;
|
||||
vertexDataPos = deferredVertexPos;
|
||||
idxWriterIndex = deferredIdxPos;
|
||||
resetLightmapState();
|
||||
if (arenaOwner == this) {
|
||||
arenaOwner = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void resetLightmapState() {
|
||||
lightmapActive = false;
|
||||
lightmapU = 0.0f;
|
||||
lightmapV = 0.0f;
|
||||
lightmapTextureId = 0;
|
||||
}
|
||||
|
||||
// === Actual text mesh generation
|
||||
|
||||
public static boolean charInRange(char what, char fromInclusive, char toInclusive) {
|
||||
@@ -808,6 +929,8 @@ public class BatchingFontRenderer {
|
||||
FontProviderMC.get(this.isSGA).locationFontTexture = this.locationFontTexture;
|
||||
|
||||
this.beginBatch();
|
||||
this.captureLightmapState();
|
||||
this.lightingFactorActive = FFPVertexLighting.modulatesVertexColor(this.lightingFactor);
|
||||
float curX = anchorX;
|
||||
try {
|
||||
final int totalStringLength = string.length();
|
||||
|
||||
@@ -70,9 +70,7 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
|
||||
private static MultiPhaseParameters.Builder tesrMaterialPhases(ResourceLocation texture, TesrMaterial material) {
|
||||
final MultiPhaseParameters.Builder b = MultiPhaseParameters.builder();
|
||||
if (texture != null) {
|
||||
b.texture(new RenderPhase.Texture(texture, false, false));
|
||||
}
|
||||
b.texture(texture != null ? new RenderPhase.Texture(texture, false, false) : NO_TEXTURE);
|
||||
if (material.isNoCull()) {
|
||||
b.cull(DISABLE_CULLING);
|
||||
}
|
||||
@@ -85,18 +83,14 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
if (material.isDepthOnly()) {
|
||||
b.writeMaskState(DEPTH_MASK);
|
||||
}
|
||||
if (material.cutoutAlpha() > 0) {
|
||||
b.alpha(new RenderPhase.Alpha(material.cutoutAlpha()));
|
||||
}
|
||||
if (material.isDepthEqual()) {
|
||||
b.depthTest(EQUAL_DEPTH_TEST);
|
||||
}
|
||||
b.alpha(material.cutoutAlpha() > 0 ? new RenderPhase.Alpha(material.cutoutAlpha()) : ZERO_ALPHA);
|
||||
b.depthTest(material.isDepthEqual() ? EQUAL_DEPTH_TEST : LEQUAL_DEPTH_TEST);
|
||||
switch (material.transparency()) {
|
||||
case TRANSLUCENT -> b.transparency(TRANSLUCENT_TRANSPARENCY);
|
||||
case ADDITIVE -> b.transparency(ADDITIVE_TRANSPARENCY);
|
||||
case ADDITIVE_ALPHA -> b.transparency(LIGHTNING_TRANSPARENCY);
|
||||
case GLINT -> b.transparency(GLINT_TRANSPARENCY);
|
||||
case OPAQUE -> {}
|
||||
case OPAQUE -> b.transparency(NO_TRANSPARENCY);
|
||||
}
|
||||
switch (material.special()) {
|
||||
case GLINT -> b.shader(SPECIAL_GLINT);
|
||||
@@ -119,21 +113,12 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
GbufferPrograms::teardownSpecialRenderCondition);
|
||||
|
||||
public static RenderLayer tesr(ResourceLocation texture, TesrMaterial material) {
|
||||
final MultiPhaseParameters.Builder b = tesrMaterialPhases(texture, material).shadeModel(SMOOTH_SHADE_MODEL).lightmap(ENABLE_LIGHTMAP);
|
||||
if (material.transparency() == TesrMaterial.Transparency.TRANSLUCENT) {
|
||||
b.target(TRANSLUCENT_TARGET);
|
||||
}
|
||||
final MultiPhaseParameters.Builder b = tesrMaterialPhases(texture, material).shadeModel(SMOOTH_SHADE_MODEL);
|
||||
final boolean sortsTranslucent = material.transparency() != TesrMaterial.Transparency.OPAQUE;
|
||||
return of("angelica_tesr_" + material.transparency().name().toLowerCase(Locale.ROOT),
|
||||
BatchVertexFormats.POSITION_COLOR_TEXTURE_LIGHTF_NORMAL, GL11.GL_QUADS, 65536, true, sortsTranslucent, b.build(false));
|
||||
}
|
||||
|
||||
public static RenderLayer tesrNoPass(ResourceLocation texture, TesrMaterial material) {
|
||||
return of("angelica_tesr_nopass_" + material.transparency().name().toLowerCase(Locale.ROOT),
|
||||
BatchVertexFormats.POSITION_COLOR_TEXTURE_LIGHTF_NORMAL, GL11.GL_QUADS, 65536, true, false,
|
||||
tesrMaterialPhases(texture, material).build(false));
|
||||
}
|
||||
|
||||
public static RenderLayer getOutline(ResourceLocation texture, RenderPhase.Cull cull) {
|
||||
return of("outline", DefaultVertexFormat.POSITION_COLOR_TEXTURE, 7, 256, RenderLayer.MultiPhaseParameters.builder().texture(new RenderPhase.Texture(texture, false, false)).cull(cull).depthTest(ALWAYS_DEPTH_TEST).alpha(ONE_TENTH_ALPHA).fog(NO_FOG).target(OUTLINE_TARGET).build(RenderLayer.OutlineMode.IS_OUTLINE));
|
||||
}
|
||||
@@ -154,7 +139,7 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
|
||||
@Override
|
||||
public TransparencyType getTransparencyType() {
|
||||
return phases.transparency.getTransparencyType();
|
||||
return phases.transparency == null ? TransparencyType.OPAQUE : phases.transparency.getTransparencyType();
|
||||
}
|
||||
|
||||
private MultiPhase(String name, VertexFormat vertexFormat, int drawMode, int expectedBufferSize, boolean hasCrumbling, boolean translucent, MultiPhaseParameters phases) {
|
||||
@@ -170,7 +155,7 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
}
|
||||
});
|
||||
this.phases = phases;
|
||||
this.affectedOutline = phases.outlineMode == RenderLayer.OutlineMode.AFFECTS_OUTLINE ? phases.texture.getId().map((arg2) -> {
|
||||
this.affectedOutline = phases.outlineMode == RenderLayer.OutlineMode.AFFECTS_OUTLINE && phases.texture != null ? phases.texture.getId().map((arg2) -> {
|
||||
return getOutline(arg2, phases.cull);
|
||||
}) : Optional.empty();
|
||||
this.hash = Objects.hash(new Object[]{super.hashCode(), phases});
|
||||
@@ -187,7 +172,7 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
|
||||
@Override
|
||||
public ResourceLocation getTextureId() {
|
||||
return phases.texture.getId().orElse(null);
|
||||
return phases.texture == null ? null : phases.texture.getId().orElse(null);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -223,7 +208,9 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
if (arg == arg2) {
|
||||
return true;
|
||||
} else {
|
||||
return arg != null && arg2 != null ? Objects.equals(arg.phases, arg2.phases) : false;
|
||||
return arg != null && arg2 != null && arg.name.equals(arg2.name)
|
||||
&& arg.getVertexFormat() == arg2.getVertexFormat() && arg.getDrawMode() == arg2.getDrawMode()
|
||||
&& Objects.equals(arg.phases, arg2.phases);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -263,7 +250,13 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
this.writeMaskState = writeMaskState;
|
||||
this.shader = shader;
|
||||
this.outlineMode = outlineMode;
|
||||
this.phases = ImmutableList.of(this.texture, this.transparency, this.diffuseLighting, this.shadeModel, this.alpha, this.depthTest, this.cull, this.lightmap, this.fog, this.layering, this.target, this.texturing, this.writeMaskState, this.shader);
|
||||
final ImmutableList.Builder<RenderPhase> declared = ImmutableList.builder();
|
||||
for (RenderPhase phase : new RenderPhase[] { this.texture, this.transparency, this.diffuseLighting,
|
||||
this.shadeModel, this.alpha, this.depthTest, this.cull, this.lightmap, this.fog, this.layering,
|
||||
this.target, this.texturing, this.writeMaskState, this.shader }) {
|
||||
if (phase != null) declared.add(phase);
|
||||
}
|
||||
this.phases = declared.build();
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -308,22 +301,7 @@ public abstract class RenderLayer extends RenderPhase { // Aka: RenderType (Iris
|
||||
private RenderPhase.WriteMaskState writeMaskState;
|
||||
private RenderPhase.Shader shader;
|
||||
|
||||
private Builder() {
|
||||
this.texture = RenderPhase.NO_TEXTURE ;
|
||||
this.transparency = RenderPhase.NO_TRANSPARENCY;
|
||||
this.diffuseLighting = RenderPhase.DISABLE_DIFFUSE_LIGHTING;
|
||||
this.shadeModel = RenderPhase.SHADE_MODEL;
|
||||
this.alpha = RenderPhase.ZERO_ALPHA;
|
||||
this.depthTest = RenderPhase.LEQUAL_DEPTH_TEST;
|
||||
this.cull = RenderPhase.ENABLE_CULLING;
|
||||
this.lightmap = RenderPhase.DISABLE_LIGHTMAP;
|
||||
this.fog = RenderPhase.FOG;
|
||||
this.layering = RenderPhase.NO_LAYERING;
|
||||
this.target = RenderPhase.MAIN_TARGET;
|
||||
this.texturing = RenderPhase.DEFAULT_TEXTURING;
|
||||
this.writeMaskState = RenderPhase.ALL_MASK;
|
||||
this.shader = RenderPhase.NO_SHADER;
|
||||
}
|
||||
private Builder() {}
|
||||
|
||||
public Builder texture(RenderPhase.Texture texture) {
|
||||
this.texture = texture;
|
||||
|
||||
@@ -57,6 +57,10 @@ public final class FlybyRunner {
|
||||
private long plotTurning;
|
||||
private int lastPhase = -1;
|
||||
|
||||
private long warmupSection;
|
||||
private long runSection;
|
||||
private long legSection;
|
||||
|
||||
private long[] frameTimesNs = NO_FRAMES;
|
||||
private int frameCount;
|
||||
private boolean framesTruncated;
|
||||
@@ -180,9 +184,13 @@ public final class FlybyRunner {
|
||||
this.buildPath();
|
||||
this.freezeTimeAndWeather(mc);
|
||||
|
||||
this.state = this.warmupTicks > 0 ? State.WARMUP : State.RUNNING;
|
||||
this.tick = 0;
|
||||
if (this.state == State.RUNNING) this.beginMeasuring();
|
||||
if (this.warmupTicks > 0) {
|
||||
this.state = State.WARMUP;
|
||||
this.warmupSection = Tracy.sectionEnter(Tracy.SECTION_BENCHMARK, "flyby warmup");
|
||||
} else {
|
||||
this.beginMeasuring();
|
||||
}
|
||||
|
||||
LOGGER.info("Flyby {} starting at {} {} {} yaw {}", this.route.id(),
|
||||
this.originX, this.originY, this.originZ, this.originYaw);
|
||||
@@ -252,12 +260,18 @@ public final class FlybyRunner {
|
||||
final int phase = (leg << 1) | turning;
|
||||
if (phase != this.lastPhase) {
|
||||
this.lastPhase = phase;
|
||||
Tracy.message("flyby " + (turning != 0 ? "turn" : "leg") + " " + leg);
|
||||
final String label = "flyby " + (turning != 0 ? "turn" : "leg") + " " + leg;
|
||||
Tracy.message(label);
|
||||
Tracy.sectionLeave(this.legSection);
|
||||
this.legSection = Tracy.sectionEnter(Tracy.SECTION_BENCHMARK, label);
|
||||
}
|
||||
}
|
||||
|
||||
private void beginMeasuring() {
|
||||
this.state = State.RUNNING;
|
||||
Tracy.sectionLeave(this.warmupSection);
|
||||
this.warmupSection = 0L;
|
||||
if (Tracy.ENABLED) this.runSection = Tracy.sectionEnter(Tracy.SECTION_BENCHMARK, "flyby " + this.route.id());
|
||||
this.plotLeg = Tracy.plotHandle("flyby.leg");
|
||||
this.plotTurning = Tracy.plotHandle("flyby.turning");
|
||||
this.lastPhase = -1;
|
||||
@@ -265,11 +279,9 @@ public final class FlybyRunner {
|
||||
this.frameCount = 0;
|
||||
this.lastFrameNs = 0L;
|
||||
this.runStartNs = System.nanoTime();
|
||||
Tracy.message("flyby start route=" + this.route.id()
|
||||
+ " length=" + this.runLength + this.route.lengthUnit()
|
||||
+ " speed=" + this.route.speedOr(this.speed) + "b/t"
|
||||
+ " ticks=" + this.runTicks
|
||||
+ " sdlgpu=" + SystemProperties.USE_SDL_GPU);
|
||||
if (Tracy.ENABLED) {
|
||||
Tracy.message("flyby start route=" + this.route.id() + " length=" + this.runLength + this.route.lengthUnit() + " speed=" + this.route.speedOr(this.speed) + "b/t ticks=" + this.runTicks + " sdlgpu=" + SystemProperties.USE_SDL_GPU);
|
||||
}
|
||||
}
|
||||
|
||||
private void holdPosition(EntityClientPlayerMP player) {
|
||||
@@ -364,7 +376,11 @@ public final class FlybyRunner {
|
||||
this.state = State.SETTLE;
|
||||
this.tick = 0;
|
||||
final long elapsedNs = System.nanoTime() - this.runStartNs;
|
||||
Tracy.message("flyby end route=" + this.route.id() + " frames=" + this.frameCount);
|
||||
Tracy.sectionLeave(this.legSection);
|
||||
this.legSection = 0L;
|
||||
Tracy.sectionLeave(this.runSection);
|
||||
this.runSection = 0L;
|
||||
if (Tracy.ENABLED) Tracy.message("flyby end route=" + this.route.id() + " frames=" + this.frameCount);
|
||||
|
||||
final String summary = this.summarise(elapsedNs, player);
|
||||
LOGGER.info(summary);
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
package com.gtnewhorizons.angelica.helpers;
|
||||
|
||||
import static com.gtnewhorizons.angelica.client.font.ColorCodeUtils.FORMATTING_CHAR;
|
||||
|
||||
import net.minecraft.entity.EntityLiving;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.util.EnumChatFormatting;
|
||||
|
||||
public final class RendererLivingEntityHelper {
|
||||
|
||||
private RendererLivingEntityHelper() {}
|
||||
|
||||
public static String getUpsideDownName(EntityLivingBase entity) {
|
||||
if (entity instanceof EntityLiving living) {
|
||||
return living.hasCustomNameTag() ? entity.getCommandSenderName() : "";
|
||||
}
|
||||
|
||||
if (entity instanceof EntityPlayer player) {
|
||||
return player.getHideCape() ? "" : entity.getCommandSenderName();
|
||||
}
|
||||
|
||||
return entity.getCommandSenderName();
|
||||
}
|
||||
|
||||
public static String stripFormattingCodes(String entityName) {
|
||||
if (entityName == null || entityName.isEmpty()) {
|
||||
return "";
|
||||
}
|
||||
|
||||
return entityName.indexOf(FORMATTING_CHAR) < 0
|
||||
? entityName
|
||||
: EnumChatFormatting.getTextWithoutFormattingCodes(entityName);
|
||||
}
|
||||
}
|
||||
@@ -70,6 +70,12 @@ public enum Mixins implements IMixins {
|
||||
)
|
||||
),
|
||||
|
||||
STARMINER_RENDERER_LIVING_ENTITY_OPTIMIZATION(new MixinBuilder()
|
||||
.setPhase(Phase.LATE)
|
||||
.addRequiredMod(TargetedMod.STARMINER)
|
||||
.addClientMixins("client.starminer.MixinTransformClientHelper")
|
||||
),
|
||||
|
||||
ANGELICA_ENTITY_OVERLAYS(new MixinBuilder()
|
||||
.setPhase(Phase.EARLY)
|
||||
.setApplyIf(() -> AngelicaConfig.entityOverlayFixes)
|
||||
@@ -377,6 +383,11 @@ public enum Mixins implements IMixins {
|
||||
, "celeritas.biome_blending.MixinBlockLiquid"
|
||||
, "celeritas.threading.MixinForgeHooksClient"
|
||||
, "celeritas.terrain.MixinChunk"
|
||||
, "celeritas.terrain.MixinWorldClient_WorkerAccess"
|
||||
, "celeritas.terrain.MixinWorld_WorkerMutationGuard"
|
||||
, "celeritas.terrain.MixinTileEntity_AwaitingDescriptor"
|
||||
, "celeritas.terrain.MixinNetHandlerPlayClient_DescriptorRepair"
|
||||
, "celeritas.terrain.MixinWorld_AwaitingDescriptor"
|
||||
, "celeritas.terrain.MixinRenderRegion"
|
||||
, "celeritas.terrain.MixinSectionRenderDataStorage"
|
||||
, "celeritas.terrain.MixinDefaultChunkRenderer"
|
||||
|
||||
@@ -24,6 +24,7 @@ public enum TargetedMod implements ITargetMod {
|
||||
IC2("ic2.core.coremod.IC2core", "IC2"),
|
||||
NATURA(null, "Natura"),
|
||||
SECURITYCRAFT(null, "securitycraft"),
|
||||
STARMINER("jp.mc.ancientred.starminer.core.SMPlugin", "modJ_StarMiner"),
|
||||
SUPERNOVA("com.mitchej123.supernova.core.SupernovaCore", "supernova"),
|
||||
THAUMCRAFT(null, "Thaumcraft"),
|
||||
TINKERS_CONSTRUCT(null, "TConstruct"),
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
package com.gtnewhorizons.angelica.mixins.interfaces;
|
||||
|
||||
public interface AwaitingDescriptorTE {
|
||||
|
||||
boolean angelica$isAwaitingDescriptor();
|
||||
|
||||
void angelica$setAwaitingDescriptor(boolean awaiting);
|
||||
|
||||
int angelica$getDescriptorWaitTicks();
|
||||
|
||||
void angelica$setDescriptorWaitTicks(int ticks);
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.gtnewhorizons.angelica.profiling;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
|
||||
import net.minecraft.client.gui.GuiMainMenu;
|
||||
import net.minecraft.client.gui.GuiScreen;
|
||||
import net.minecraft.client.gui.GuiIngameMenu;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public final class TracyUiSections {
|
||||
|
||||
private static final Map<Class<?>, String> LABELS = new HashMap<>();
|
||||
private static Class<?> current = TracyUiSections.class;
|
||||
private static long section;
|
||||
|
||||
private TracyUiSections() {}
|
||||
|
||||
public static void poll(GuiScreen screen) {
|
||||
if (!Tracy.ENABLED) return;
|
||||
final Class<?> screenClass = screen == null ? null : screen.getClass();
|
||||
if (screenClass == current) return;
|
||||
current = screenClass;
|
||||
Tracy.sectionLeave(section);
|
||||
section = Tracy.sectionEnter(Tracy.SECTION_UI, label(screenClass));
|
||||
}
|
||||
|
||||
private static String label(Class<?> screenClass) {
|
||||
if (screenClass == null) return "in world";
|
||||
String label = LABELS.get(screenClass);
|
||||
if (label == null) {
|
||||
if (screenClass == GuiMainMenu.class) label = "main menu";
|
||||
else if (screenClass == GuiIngameMenu.class) label = "pause";
|
||||
else label = screenClass.getSimpleName();
|
||||
LABELS.put(screenClass, label);
|
||||
}
|
||||
return label;
|
||||
}
|
||||
}
|
||||
@@ -55,6 +55,7 @@ import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.config.EntityLightConfig;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.backend.VSyncMode;
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
|
||||
import com.gtnewhorizons.angelica.hudcaching.HUDCaching;
|
||||
import com.gtnewhorizons.angelica.iris.IrisGLSMBridge;
|
||||
import com.gtnewhorizons.angelica.loading.AngelicaClientTweaker;
|
||||
@@ -216,9 +217,15 @@ public final class ClientProxy extends CommonProxy {
|
||||
}
|
||||
}
|
||||
|
||||
private long worldSection;
|
||||
|
||||
@SubscribeEvent
|
||||
public void worldLoad(WorldEvent.Load event) {
|
||||
if (!event.world.isRemote) return;
|
||||
if (Tracy.ENABLED) {
|
||||
Tracy.sectionLeave(this.worldSection);
|
||||
this.worldSection = Tracy.sectionEnter(Tracy.SECTION_WORLD, "world " + event.world.provider.getDimensionName() + " (dim " + event.world.provider.dimensionId + ")");
|
||||
}
|
||||
if (GLStateManager.isRunningSplash()) {
|
||||
GLStateManager.setRunningSplash(false);
|
||||
LOGGER.info("World loaded - Enabling GLSM Cache");
|
||||
@@ -238,6 +245,8 @@ public final class ClientProxy extends CommonProxy {
|
||||
@SubscribeEvent
|
||||
public void onWorldUnload(WorldEvent.Unload event) {
|
||||
if (!event.world.isRemote) return;
|
||||
Tracy.sectionLeave(this.worldSection);
|
||||
this.worldSection = 0L;
|
||||
DynamicLights.get().removeAllLightSources();
|
||||
GpuCulling.onWorldUnload();
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
|
||||
public class RenderThreadContext {
|
||||
|
||||
@@ -15,10 +15,13 @@ public class RenderThreadContext {
|
||||
currentWorldSlice.remove();
|
||||
}
|
||||
|
||||
public static TileEntity getSnapshotTE(int x, int y, int z) {
|
||||
final WorldSlice slice = currentWorldSlice.get();
|
||||
if (slice == null) return null;
|
||||
return slice.getTileEntity(x, y, z);
|
||||
public static WorldSlice get() {
|
||||
return currentWorldSlice.get();
|
||||
}
|
||||
|
||||
public static WorldSlice workerSlice() {
|
||||
if (TessellatorManager.isOnMainThread()) return null;
|
||||
return currentWorldSlice.get();
|
||||
}
|
||||
|
||||
public static boolean hasWorldSlice() {
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
import java.io.File;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.security.CodeSource;
|
||||
import java.util.Arrays;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.IRenderingRegistryExt;
|
||||
|
||||
import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler;
|
||||
import cpw.mods.fml.client.registry.RenderingRegistry;
|
||||
import cpw.mods.fml.common.Loader;
|
||||
import cpw.mods.fml.common.ModContainer;
|
||||
import cpw.mods.fml.common.registry.GameRegistry;
|
||||
import cpw.mods.fml.common.registry.GameRegistry.UniqueIdentifier;
|
||||
|
||||
public final class WorkerWorldAccess {
|
||||
|
||||
private static final String REPORT_URL = "https://github.com/GTNewHorizons/angelica/issues";
|
||||
private static final int INITIAL_SLOTS = 64;
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("Angelica");
|
||||
|
||||
private static final LoggedRenderTypeErrors READS = new LoggedRenderTypeErrors();
|
||||
private static final LoggedRenderTypeErrors WRITES = new LoggedRenderTypeErrors();
|
||||
|
||||
private WorkerWorldAccess() {}
|
||||
|
||||
public static void readOutsideSlice(String worldMethod, int x, int y, int z, Block renderingBlock) {
|
||||
if (!READS.shouldLog(renderingBlock)) return;
|
||||
LOGGER.warn(describe(worldMethod, "read outside the chunk slice", x, y, z, renderingBlock), new Throwable());
|
||||
}
|
||||
|
||||
public static void blockedWrite(String worldMethod, int x, int y, int z, Block renderingBlock) {
|
||||
if (!WRITES.shouldLog(renderingBlock)) return;
|
||||
LOGGER.error(describe(worldMethod, "ignored, it would corrupt world data", x, y, z, renderingBlock), new Throwable());
|
||||
}
|
||||
|
||||
private static String describe(String worldMethod, String outcome, int x, int y, int z, Block block) {
|
||||
final StringBuilder sb = new StringBuilder(224);
|
||||
sb.append("Off-thread World.").append(worldMethod).append(' ').append(outcome).append(" at ").append(x).append(',').append(y).append(',').append(z);
|
||||
if (block != null) {
|
||||
sb.append(". Rendering ").append(nameOf(block));
|
||||
final ISimpleBlockRenderingHandler isbrh = isbrhOf(block);
|
||||
if (isbrh != null) {
|
||||
sb.append(" via ").append(isbrh.getClass().getName());
|
||||
final String owner = modIdOf(isbrh.getClass());
|
||||
if (owner != null) sb.append(" from ").append(owner);
|
||||
}
|
||||
}
|
||||
return sb.append(". Please report with this trace: ").append(REPORT_URL).toString();
|
||||
}
|
||||
|
||||
private static String nameOf(Block block) {
|
||||
try {
|
||||
final UniqueIdentifier id = GameRegistry.findUniqueIdentifierFor(block);
|
||||
if (id != null) return id.modId + ':' + id.name;
|
||||
} catch (Throwable ignored) {}
|
||||
return block.getClass().getName();
|
||||
}
|
||||
|
||||
@SuppressWarnings("deprecation")
|
||||
private static ISimpleBlockRenderingHandler isbrhOf(Block block) {
|
||||
try {
|
||||
return ((IRenderingRegistryExt) RenderingRegistry.instance()).getISBRH(block.getRenderType());
|
||||
} catch (Throwable ignored) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static String modIdOf(Class<?> clazz) {
|
||||
try {
|
||||
final CodeSource source = clazz.getProtectionDomain() == null ? null : clazz.getProtectionDomain().getCodeSource();
|
||||
if (source == null || source.getLocation() == null) return null;
|
||||
final File jar = new File(jarFileUrl(source.getLocation()).toURI());
|
||||
for (ModContainer mod : Loader.instance().getModList()) {
|
||||
if (jar.equals(mod.getSource())) return mod.getModId();
|
||||
}
|
||||
} catch (Throwable ignored) {}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static URL jarFileUrl(URL location) throws MalformedURLException {
|
||||
if (!"jar".equals(location.getProtocol())) return location;
|
||||
final String nested = location.getPath();
|
||||
final int separator = nested.indexOf("!/");
|
||||
return new URL(separator < 0 ? nested : nested.substring(0, separator));
|
||||
}
|
||||
|
||||
private static final class LoggedRenderTypeErrors {
|
||||
|
||||
private volatile boolean[] logged = new boolean[INITIAL_SLOTS];
|
||||
|
||||
boolean shouldLog(Block block) {
|
||||
final int renderType = block == null ? -1 : block.getRenderType();
|
||||
final int slot = renderType < 0 ? 0 : renderType + 1;
|
||||
final boolean[] current = this.logged;
|
||||
return (slot >= current.length || !current[slot]) && markLogged(slot);
|
||||
}
|
||||
|
||||
private synchronized boolean markLogged(int slot) {
|
||||
boolean[] current = this.logged;
|
||||
if (slot < current.length) {
|
||||
if (current[slot]) return false;
|
||||
current[slot] = true;
|
||||
return true;
|
||||
}
|
||||
current = Arrays.copyOf(current, Math.max(slot + 1, current.length * 2));
|
||||
current[slot] = true;
|
||||
this.logged = current;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
+5
@@ -9,6 +9,7 @@ import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.iris.BlockRenderContext;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.iris.ContextAwareChunkVertexEncoder;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
import com.prupe.mcpatcher.mal.block.RenderBlocksUtils;
|
||||
import it.unimi.dsi.fastutil.floats.FloatArrayList;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ReferenceMap;
|
||||
@@ -111,6 +112,8 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
|
||||
|
||||
final BlockPos blockPos = new BlockPos(minX, minY, minZ);
|
||||
final IBlockAccess region = getBlockAccess();
|
||||
final WorldSlice reportingSlice = region instanceof WorldSlice slice ? slice : null;
|
||||
if (reportingSlice != null) reportingSlice.setRenderingBlock(null);
|
||||
final SmoothBiomeColorCache biomeColorCache = getBiomeColorCache();
|
||||
|
||||
onEnterExecute();
|
||||
@@ -155,6 +158,8 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
|
||||
continue;
|
||||
}
|
||||
|
||||
if (reportingSlice != null) reportingSlice.setRenderingBlock(block);
|
||||
|
||||
final int meta = region.getBlockMetadata(x, y, z);
|
||||
|
||||
if (block.hasTileEntity(meta)) {
|
||||
|
||||
@@ -104,6 +104,7 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess {
|
||||
// The chunk origin of this slice
|
||||
private ChunkSectionPos origin;
|
||||
private StructureBoundingBox volume;
|
||||
private Block renderingBlock;
|
||||
|
||||
private final SmoothBiomeColorCache biomeColorCache;
|
||||
|
||||
@@ -530,6 +531,18 @@ public class WorldSlice implements IBlockAccessExtended, FLBlockAccess {
|
||||
return y << TABLE_BITS << TABLE_BITS | z << TABLE_BITS | x;
|
||||
}
|
||||
|
||||
public boolean containsBlock(int x, int y, int z) {
|
||||
return blockBoxContains(this.volume, x, y, z);
|
||||
}
|
||||
|
||||
public void setRenderingBlock(Block block) {
|
||||
this.renderingBlock = block;
|
||||
}
|
||||
|
||||
public Block getRenderingBlock() {
|
||||
return this.renderingBlock;
|
||||
}
|
||||
|
||||
private static boolean blockBoxContains(StructureBoundingBox box, int x, int y, int z) {
|
||||
return x >= box.minX && x <= box.maxX &&
|
||||
y >= box.minY && y <= box.maxY &&
|
||||
|
||||
@@ -158,9 +158,8 @@ public final class TesrBatchRenderer {
|
||||
boolean depthEqual;
|
||||
TesrMaterial.SpecialRender special;
|
||||
TesrShader shader;
|
||||
boolean noPass;
|
||||
|
||||
LayerKey set(ResourceLocation texture, TesrMaterial.Transparency transparency, boolean noCull, boolean unlit, boolean noDepthWrite, boolean depthOnly, float cutoutAlpha, boolean depthEqual, TesrMaterial.SpecialRender special, TesrShader shader, boolean noPass) {
|
||||
LayerKey set(ResourceLocation texture, TesrMaterial.Transparency transparency, boolean noCull, boolean unlit, boolean noDepthWrite, boolean depthOnly, float cutoutAlpha, boolean depthEqual, TesrMaterial.SpecialRender special, TesrShader shader) {
|
||||
this.texture = texture;
|
||||
this.transparency = transparency;
|
||||
this.noCull = noCull;
|
||||
@@ -171,12 +170,11 @@ public final class TesrBatchRenderer {
|
||||
this.depthEqual = depthEqual;
|
||||
this.special = special;
|
||||
this.shader = shader;
|
||||
this.noPass = noPass;
|
||||
return this;
|
||||
}
|
||||
|
||||
LayerKey copy() {
|
||||
return new LayerKey().set(texture, transparency, noCull, unlit, noDepthWrite, depthOnly, cutoutAlpha, depthEqual, special, shader, noPass);
|
||||
return new LayerKey().set(texture, transparency, noCull, unlit, noDepthWrite, depthOnly, cutoutAlpha, depthEqual, special, shader);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -186,7 +184,7 @@ public final class TesrBatchRenderer {
|
||||
&& noCull == other.noCull && unlit == other.unlit && noDepthWrite == other.noDepthWrite
|
||||
&& depthOnly == other.depthOnly
|
||||
&& Float.floatToIntBits(cutoutAlpha) == Float.floatToIntBits(other.cutoutAlpha)
|
||||
&& depthEqual == other.depthEqual && special == other.special && shader == other.shader && noPass == other.noPass;
|
||||
&& depthEqual == other.depthEqual && special == other.special && shader == other.shader;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -201,7 +199,6 @@ public final class TesrBatchRenderer {
|
||||
h = h * 31 + (depthEqual ? 1 : 0);
|
||||
h = h * 31 + Objects.hashCode(special);
|
||||
h = h * 31 + System.identityHashCode(shader);
|
||||
h = h * 31 + (noPass ? 1 : 0);
|
||||
return h;
|
||||
}
|
||||
}
|
||||
@@ -211,37 +208,23 @@ public final class TesrBatchRenderer {
|
||||
private ResourceLocation lastLayerTexture;
|
||||
private TesrMaterial lastLayerMaterial;
|
||||
private RenderLayer lastLayer;
|
||||
private ResourceLocation lastImmediateTexture;
|
||||
private TesrMaterial lastImmediateMaterial;
|
||||
private RenderLayer lastImmediateLayer;
|
||||
|
||||
private RenderLayer layerFor(ResourceLocation texture, TesrMaterial material) {
|
||||
if (texture == lastLayerTexture && material == lastLayerMaterial) {
|
||||
return lastLayer;
|
||||
}
|
||||
final RenderLayer layer = layerLookup(texture, material, false);
|
||||
final RenderLayer layer = layerLookup(texture, material);
|
||||
lastLayerTexture = texture;
|
||||
lastLayerMaterial = material;
|
||||
lastLayer = layer;
|
||||
return layer;
|
||||
}
|
||||
|
||||
private RenderLayer noPassLayerFor(ResourceLocation texture, TesrMaterial material) {
|
||||
if (texture == lastImmediateTexture && material == lastImmediateMaterial) {
|
||||
return lastImmediateLayer;
|
||||
}
|
||||
final RenderLayer layer = layerLookup(texture, material, true);
|
||||
lastImmediateTexture = texture;
|
||||
lastImmediateMaterial = material;
|
||||
lastImmediateLayer = layer;
|
||||
return layer;
|
||||
}
|
||||
|
||||
private RenderLayer layerLookup(ResourceLocation texture, TesrMaterial material, boolean noPass) {
|
||||
final LayerKey key = scratchKey.set(texture, material.transparency(), material.isNoCull(), material.isUnlit(), material.isNoDepthWrite(), material.isDepthOnly(), material.cutoutAlpha(), material.isDepthEqual(), material.special(), material.shader(), noPass);
|
||||
private RenderLayer layerLookup(ResourceLocation texture, TesrMaterial material) {
|
||||
final LayerKey key = scratchKey.set(texture, material.transparency(), material.isNoCull(), material.isUnlit(), material.isNoDepthWrite(), material.isDepthOnly(), material.cutoutAlpha(), material.isDepthEqual(), material.special(), material.shader());
|
||||
RenderLayer layer = layers.get(key);
|
||||
if (layer == null) {
|
||||
layer = noPass ? RenderLayer.tesrNoPass(texture, material) : RenderLayer.tesr(texture, material);
|
||||
layer = RenderLayer.tesr(texture, material);
|
||||
layers.put(key.copy(), layer);
|
||||
}
|
||||
return layer;
|
||||
@@ -469,7 +452,7 @@ public final class TesrBatchRenderer {
|
||||
final long end = VertexTransform.writeInstance(addr, format, template, identity, scratchVec, colorABGR, packedLight, null);
|
||||
immediateScratch.position((int) (end - addr));
|
||||
immediateScratch.flip();
|
||||
final RenderLayer layer = noPassLayerFor(texture, material);
|
||||
final RenderLayer layer = layerFor(texture, material);
|
||||
GLStateManager.glPushAttrib(AngelicaBufferSource.SAVED_STATE_BITS);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
layer.startDrawing();
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
package com.gtnewhorizons.angelica.utils;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.AwaitingDescriptorTE;
|
||||
|
||||
public final class AwaitingDescriptor {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("Angelica");
|
||||
|
||||
private static final int WAIT_TICKS = 100;
|
||||
|
||||
private static final Map<Class<?>, Boolean> SENDS_DESCRIPTOR = new ConcurrentHashMap<>();
|
||||
|
||||
private AwaitingDescriptor() {}
|
||||
|
||||
public static void begin(TileEntity te) {
|
||||
if (!SENDS_DESCRIPTOR.computeIfAbsent(te.getClass(), AwaitingDescriptor::sendsDescriptor)) return;
|
||||
|
||||
final AwaitingDescriptorTE tile = (AwaitingDescriptorTE) te;
|
||||
tile.angelica$setAwaitingDescriptor(true);
|
||||
tile.angelica$setDescriptorWaitTicks(WAIT_TICKS);
|
||||
}
|
||||
|
||||
public static void end(AwaitingDescriptorTE tile) {
|
||||
tile.angelica$setAwaitingDescriptor(false);
|
||||
tile.angelica$setDescriptorWaitTicks(0);
|
||||
}
|
||||
|
||||
public static boolean defersUpdate(TileEntity te) {
|
||||
final AwaitingDescriptorTE tile = (AwaitingDescriptorTE) te;
|
||||
final int waiting = tile.angelica$getDescriptorWaitTicks();
|
||||
if (waiting <= 0) return false;
|
||||
|
||||
tile.angelica$setDescriptorWaitTicks(waiting - 1);
|
||||
if (waiting == 1) stopWaitingOn(te.getClass());
|
||||
return true;
|
||||
}
|
||||
|
||||
private static boolean sendsDescriptor(Class<?> cls) {
|
||||
try {
|
||||
return cls.getMethod("getDescriptionPacket").getDeclaringClass() != TileEntity.class;
|
||||
} catch (NoSuchMethodException e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static void stopWaitingOn(Class<?> cls) {
|
||||
if (!Boolean.TRUE.equals(SENDS_DESCRIPTOR.put(cls, Boolean.FALSE))) return;
|
||||
LOGGER.warn("{} declares getDescriptionPacket() but never sent one", cls.getName());
|
||||
}
|
||||
}
|
||||
@@ -202,7 +202,8 @@ public class ConcurrentTileEntityMap extends HashMap<ChunkPosition, TileEntity>
|
||||
if (!isRenderWorkerThread()) return delegate.containsKey(key);
|
||||
lock.readLock().lock();
|
||||
try {
|
||||
return delegate.containsKey(key);
|
||||
final TileEntity te = delegate.get(key);
|
||||
return te != null && !te.isInvalid();
|
||||
} finally {
|
||||
lock.readLock().unlock();
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package net.coderbot.iris.pipeline;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
|
||||
import lombok.Getter;
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.uniforms.SystemTimeUniforms;
|
||||
@@ -19,6 +20,7 @@ public class PipelineManager {
|
||||
private final Map<String, WorldRenderingPipeline> pipelinesPerDimension = new HashMap<>();
|
||||
private WorldRenderingPipeline pipeline = new FixedFunctionWorldRenderingPipeline();
|
||||
private String lastPreparedDimension = null;
|
||||
private long shaderSection;
|
||||
@Getter
|
||||
private int versionCounterForSodiumShaderReload = 0;
|
||||
|
||||
@@ -41,6 +43,9 @@ public class PipelineManager {
|
||||
Iris.logger.info("Creating pipeline for dimension '{}'", currentDimension);
|
||||
pipeline = pipelineFactory.apply(currentDimension);
|
||||
pipelinesPerDimension.put(currentDimension, pipeline);
|
||||
if (Tracy.ENABLED) {
|
||||
shaderSection = Tracy.sectionEnter(Tracy.SECTION_SHADERS, "shaders " + Iris.getCurrentPackName() + " / " + currentDimension);
|
||||
}
|
||||
} else {
|
||||
pipeline = pipelinesPerDimension.get(currentDimension);
|
||||
}
|
||||
@@ -70,6 +75,8 @@ public class PipelineManager {
|
||||
* @see <a href="https://github.com/IrisShaders/Iris/issues/1330">this GitHub issue</a>
|
||||
*/
|
||||
public void destroyPipeline() {
|
||||
Tracy.sectionLeave(shaderSection);
|
||||
shaderSection = 0L;
|
||||
pipelinesPerDimension.forEach((dimensionName, pipeline) -> {
|
||||
Iris.logger.info("Destroying pipeline for dimension '{}'", dimensionName);
|
||||
resetTextureState();
|
||||
|
||||
@@ -6,7 +6,7 @@ import net.coderbot.iris.gl.uniform.UniformUpdateFrequency;
|
||||
import org.joml.Matrix4f;
|
||||
|
||||
public class BuiltinReplacementUniforms {
|
||||
private static final Matrix4f lightmapTextureMatrix;
|
||||
public static final Matrix4f lightmapTextureMatrix;
|
||||
|
||||
static {
|
||||
// This mimics the transformations done in LightTexture to the GL_TEXTURE matrix.
|
||||
|
||||
@@ -6,6 +6,8 @@ layout(location = 2) in vec4 a_Color;
|
||||
layout(location = 3) in vec4 a_TexBounds;
|
||||
|
||||
uniform mat4 u_MVPMatrix;
|
||||
uniform vec3 u_Lightmap;
|
||||
uniform sampler2D lightmap;
|
||||
|
||||
out vec4 tB;
|
||||
out vec4 color;
|
||||
@@ -15,5 +17,10 @@ void main() {
|
||||
gl_Position = u_MVPMatrix * vec4(a_Position, 0.0, 1.0);
|
||||
texCoord = a_TexCoord0;
|
||||
color = a_Color;
|
||||
|
||||
if (u_Lightmap.z > 0.5) {
|
||||
color.rgb *= textureLod(lightmap, u_Lightmap.xy, 0.0).rgb;
|
||||
}
|
||||
|
||||
tB = a_TexBounds;
|
||||
}
|
||||
+22
-37
@@ -1,48 +1,33 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.angelica.optimizations;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.helpers.RendererLivingEntityHelper;
|
||||
import net.minecraft.client.renderer.entity.RendererLivingEntity;
|
||||
import net.minecraft.entity.EntityLiving;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.util.EnumChatFormatting;
|
||||
import net.minecraft.util.MathHelper;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Overwrite;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Redirect;
|
||||
|
||||
@Mixin(RendererLivingEntity.class)
|
||||
public abstract class MixinRendererLivingEntity {
|
||||
public class MixinRendererLivingEntity {
|
||||
|
||||
@Shadow protected abstract float getDeathMaxRotation(EntityLivingBase entity);
|
||||
|
||||
/**
|
||||
* @author mitchej123
|
||||
* @reason The vanilla method triggers way too many allocations for no good reason
|
||||
*/
|
||||
@Overwrite
|
||||
protected void rotateCorpse(EntityLivingBase entity, float p_77043_2_, float p_77043_3_, float partialTicks) {
|
||||
GLStateManager.glRotatef(180.0F - p_77043_3_, 0.0F, 1.0F, 0.0F);
|
||||
|
||||
if (entity.deathTime > 0) {
|
||||
float f3 = ((float)entity.deathTime + partialTicks - 1.0F) / 20.0F * 1.6F;
|
||||
f3 = MathHelper.sqrt_float(f3);
|
||||
|
||||
if (f3 > 1.0F) {
|
||||
f3 = 1.0F;
|
||||
}
|
||||
|
||||
GLStateManager.glRotatef(f3 * this.getDeathMaxRotation(entity), 0.0F, 0.0F, 1.0F);
|
||||
}
|
||||
else if ((entity instanceof EntityLiving entityLiving) && entityLiving.hasCustomNameTag() || (entity instanceof EntityPlayer entityPlayer) && !entityPlayer.getHideCape()) {
|
||||
|
||||
final String s = EnumChatFormatting.getTextWithoutFormattingCodes(entity.getCommandSenderName());
|
||||
|
||||
if ((s.equals("Dinnerbone") || s.equals("Grumm"))) {
|
||||
GLStateManager.glTranslatef(0.0F, entity.height + 0.1F, 0.0F);
|
||||
GLStateManager.glRotatef(180.0F, 0.0F, 0.0F, 1.0F);
|
||||
}
|
||||
}
|
||||
@Redirect(
|
||||
method = "rotateCorpse",
|
||||
at = @At(
|
||||
value = "INVOKE",
|
||||
target = "Lnet/minecraft/entity/EntityLivingBase;getCommandSenderName()Ljava/lang/String;"),
|
||||
require = 0)
|
||||
private static String angelica$skipUnusedEntityName(EntityLivingBase entity) {
|
||||
return RendererLivingEntityHelper.getUpsideDownName(entity);
|
||||
}
|
||||
|
||||
@Redirect(
|
||||
method = "rotateCorpse",
|
||||
at = @At(
|
||||
value = "INVOKE",
|
||||
target = "Lnet/minecraft/util/EnumChatFormatting;getTextWithoutFormattingCodes(Ljava/lang/String;)Ljava/lang/String;"),
|
||||
require = 0)
|
||||
private static String angelica$skipUnusedNameFormatting(String entityName) {
|
||||
return RendererLivingEntityHelper.stripFormattingCodes(entityName);
|
||||
}
|
||||
}
|
||||
+2
@@ -3,6 +3,7 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.tracy;
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
|
||||
import com.gtnewhorizons.angelica.profiling.GpuFrameLagMeter;
|
||||
import com.gtnewhorizons.angelica.profiling.TracyFramePlots;
|
||||
import com.gtnewhorizons.angelica.profiling.TracyUiSections;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
@@ -20,6 +21,7 @@ public class MixinMinecraft_Tracy {
|
||||
TracyFramePlots.onFrame((Minecraft) (Object) this);
|
||||
GpuFrameLagMeter.onFrame();
|
||||
Tracy.frameMark();
|
||||
TracyUiSections.poll(((Minecraft) (Object) this).currentScreen);
|
||||
Tracy.gpuCollect();
|
||||
}
|
||||
|
||||
|
||||
+20
-10
@@ -25,6 +25,8 @@ import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.event.ChunkBiomeDataChangedEvent;
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.IChunkTileEntityMapHolder;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
import com.gtnewhorizons.angelica.utils.AwaitingDescriptor;
|
||||
import com.gtnewhorizons.angelica.utils.ConcurrentTileEntityMap;
|
||||
|
||||
@Mixin(Chunk.class)
|
||||
@@ -60,22 +62,29 @@ public abstract class MixinChunk implements IChunkTileEntityMapHolder {
|
||||
|
||||
@Redirect(method = "getTileEntityUnsafe", at = @At(value = "INVOKE", target = "Ljava/util/Map;get(Ljava/lang/Object;)Ljava/lang/Object;"), remap = false)
|
||||
private Object angelica$redirectGetTEUnsafe(Map<ChunkPosition, TileEntity> map, Object key) {
|
||||
if (RenderThreadContext.hasWorldSlice()) {
|
||||
return angelica$snapshotFirst(map, key);
|
||||
}
|
||||
|
||||
@Redirect(method = "func_150806_e", at = @At(value = "INVOKE", target = "Ljava/util/Map;get(Ljava/lang/Object;)Ljava/lang/Object;"))
|
||||
private Object angelica$redirectGetTEFunc(Map<ChunkPosition, TileEntity> map, Object key) {
|
||||
return angelica$snapshotFirst(map, key);
|
||||
}
|
||||
|
||||
@Unique
|
||||
private Object angelica$snapshotFirst(Map<ChunkPosition, TileEntity> map, Object key) {
|
||||
final WorldSlice slice = RenderThreadContext.get();
|
||||
if (slice != null) {
|
||||
final ChunkPosition pos = (ChunkPosition) key;
|
||||
final TileEntity te = RenderThreadContext.getSnapshotTE((this.xPosition << 4) + pos.chunkPosX, pos.chunkPosY, (this.zPosition << 4) + pos.chunkPosZ);
|
||||
final TileEntity te = slice.getTileEntity((this.xPosition << 4) + pos.chunkPosX, pos.chunkPosY, (this.zPosition << 4) + pos.chunkPosZ);
|
||||
if (te != null) return te;
|
||||
}
|
||||
return map.get(key);
|
||||
}
|
||||
|
||||
@Redirect(method = "func_150806_e", at = @At(value = "INVOKE", target = "Ljava/util/Map;get(Ljava/lang/Object;)Ljava/lang/Object;"))
|
||||
private Object angelica$redirectGetTEFunc(Map<ChunkPosition, TileEntity> map, Object key) {
|
||||
if (RenderThreadContext.hasWorldSlice()) {
|
||||
final ChunkPosition pos = (ChunkPosition) key;
|
||||
final TileEntity te = RenderThreadContext.getSnapshotTE((this.xPosition << 4) + pos.chunkPosX, pos.chunkPosY, (this.zPosition << 4) + pos.chunkPosZ);
|
||||
if (te != null) return te;
|
||||
}
|
||||
return map.get(key);
|
||||
@Redirect(method = "func_150806_e", at = @At(value = "INVOKE", target = "Lnet/minecraft/block/Block;hasTileEntity(I)Z"), remap = false)
|
||||
private boolean angelica$noWorkerTileEntityCreation(Block block, int meta) {
|
||||
if (RenderThreadContext.hasWorldSlice()) return false;
|
||||
return block.hasTileEntity(meta);
|
||||
}
|
||||
|
||||
@Redirect(method = "func_150806_e", at = @At(value = "INVOKE", target = "Ljava/util/Map;remove(Ljava/lang/Object;)Ljava/lang/Object;"))
|
||||
@@ -129,6 +138,7 @@ public abstract class MixinChunk implements IChunkTileEntityMapHolder {
|
||||
te.xCoord = (this.xPosition << 4) + x;
|
||||
te.yCoord = worldY;
|
||||
te.zCoord = (this.zPosition << 4) + z;
|
||||
AwaitingDescriptor.begin(te);
|
||||
this.addTileEntity(te);
|
||||
}
|
||||
}
|
||||
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain;
|
||||
|
||||
import net.minecraft.client.multiplayer.WorldClient;
|
||||
import net.minecraft.client.network.NetHandlerPlayClient;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Redirect;
|
||||
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.AwaitingDescriptorTE;
|
||||
import com.gtnewhorizons.angelica.utils.AwaitingDescriptor;
|
||||
|
||||
@Mixin(NetHandlerPlayClient.class)
|
||||
public class MixinNetHandlerPlayClient_DescriptorRepair {
|
||||
|
||||
@Redirect(method = "handleUpdateTileEntity",
|
||||
at = @At(value = "INVOKE", target = "Lnet/minecraft/client/multiplayer/WorldClient;getTileEntity(III)Lnet/minecraft/tileentity/TileEntity;"))
|
||||
private TileEntity angelica$remeshOnFirstDescriptor(WorldClient world, int x, int y, int z) {
|
||||
final TileEntity te = world.getTileEntity(x, y, z);
|
||||
if (te instanceof AwaitingDescriptorTE awaiting && awaiting.angelica$isAwaitingDescriptor()) {
|
||||
AwaitingDescriptor.end(awaiting);
|
||||
world.markBlockForUpdate(x, y, z);
|
||||
}
|
||||
return te;
|
||||
}
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain;
|
||||
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Unique;
|
||||
|
||||
import com.gtnewhorizons.angelica.mixins.interfaces.AwaitingDescriptorTE;
|
||||
|
||||
@Mixin(TileEntity.class)
|
||||
public abstract class MixinTileEntity_AwaitingDescriptor implements AwaitingDescriptorTE {
|
||||
|
||||
@Unique private boolean angelica$awaitingDescriptor;
|
||||
|
||||
@Unique private int angelica$descriptorWaitTicks;
|
||||
|
||||
@Override
|
||||
public boolean angelica$isAwaitingDescriptor() {
|
||||
return this.angelica$awaitingDescriptor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void angelica$setAwaitingDescriptor(boolean awaiting) {
|
||||
this.angelica$awaitingDescriptor = awaiting;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int angelica$getDescriptorWaitTicks() {
|
||||
return this.angelica$descriptorWaitTicks;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void angelica$setDescriptorWaitTicks(int ticks) {
|
||||
this.angelica$descriptorWaitTicks = ticks;
|
||||
}
|
||||
}
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.client.multiplayer.WorldClient;
|
||||
import net.minecraft.profiler.Profiler;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraft.world.WorldProvider;
|
||||
import net.minecraft.world.WorldSettings;
|
||||
import net.minecraft.world.biome.BiomeGenBase;
|
||||
import net.minecraft.world.storage.ISaveHandler;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Unique;
|
||||
|
||||
import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
|
||||
import com.gtnewhorizons.angelica.rendering.WorkerWorldAccess;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
|
||||
@Mixin(WorldClient.class)
|
||||
public abstract class MixinWorldClient_WorkerAccess extends World {
|
||||
|
||||
private MixinWorldClient_WorkerAccess(ISaveHandler saveHandler, String name, WorldProvider provider, WorldSettings settings, Profiler profiler) {
|
||||
super(saveHandler, name, provider, settings, profiler);
|
||||
}
|
||||
|
||||
@Unique
|
||||
private static WorldSlice angelica$workerSlice(String method, int x, int y, int z) {
|
||||
final WorldSlice slice = RenderThreadContext.workerSlice();
|
||||
if (slice != null && !slice.containsBlock(x, y, z)) {
|
||||
WorkerWorldAccess.readOutsideSlice(method, x, y, z, slice.getRenderingBlock());
|
||||
}
|
||||
return slice;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Block getBlock(int x, int y, int z) {
|
||||
final WorldSlice slice = angelica$workerSlice("getBlock", x, y, z);
|
||||
return slice == null ? super.getBlock(x, y, z) : slice.getBlock(x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getBlockMetadata(int x, int y, int z) {
|
||||
final WorldSlice slice = angelica$workerSlice("getBlockMetadata", x, y, z);
|
||||
return slice == null ? super.getBlockMetadata(x, y, z) : slice.getBlockMetadata(x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public TileEntity getTileEntity(int x, int y, int z) {
|
||||
final WorldSlice slice = angelica$workerSlice("getTileEntity", x, y, z);
|
||||
return slice == null ? super.getTileEntity(x, y, z) : slice.getTileEntity(x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getLightBrightnessForSkyBlocks(int x, int y, int z, int min) {
|
||||
final WorldSlice slice = angelica$workerSlice("getLightBrightnessForSkyBlocks", x, y, z);
|
||||
return slice == null ? super.getLightBrightnessForSkyBlocks(x, y, z, min) : slice.getLightBrightnessForSkyBlocks(x, y, z, min);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isSideSolid(int x, int y, int z, ForgeDirection side, boolean _default) {
|
||||
final WorldSlice slice = angelica$workerSlice("isSideSolid", x, y, z);
|
||||
return slice == null ? super.isSideSolid(x, y, z, side, _default) : slice.isSideSolid(x, y, z, side, _default);
|
||||
}
|
||||
|
||||
@Override
|
||||
public BiomeGenBase getBiomeGenForCoords(int x, int z) {
|
||||
final WorldSlice slice = RenderThreadContext.workerSlice();
|
||||
return slice == null ? super.getBiomeGenForCoords(x, z) : slice.getBiomeGenForCoords(x, z);
|
||||
}
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain;
|
||||
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Redirect;
|
||||
|
||||
import com.gtnewhorizons.angelica.utils.AwaitingDescriptor;
|
||||
|
||||
@Mixin(World.class)
|
||||
public class MixinWorld_AwaitingDescriptor {
|
||||
|
||||
@Redirect(method = "updateEntities", at = @At(value = "INVOKE", target = "Lnet/minecraft/tileentity/TileEntity;updateEntity()V"))
|
||||
private void angelica$skipUntilDescriptorArrives(TileEntity te) {
|
||||
if (!AwaitingDescriptor.defersUpdate(te)) {
|
||||
te.updateEntity();
|
||||
}
|
||||
}
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain;
|
||||
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
||||
|
||||
import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
|
||||
import com.gtnewhorizons.angelica.rendering.WorkerWorldAccess;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
|
||||
@Mixin(World.class)
|
||||
public abstract class MixinWorld_WorkerMutationGuard {
|
||||
|
||||
@Inject(method = "setTileEntity", at = @At("HEAD"), cancellable = true)
|
||||
private void angelica$blockWorkerSetTileEntity(int x, int y, int z, TileEntity tileEntity, CallbackInfo ci) {
|
||||
final WorldSlice slice = RenderThreadContext.workerSlice();
|
||||
if (slice == null) return;
|
||||
WorkerWorldAccess.blockedWrite("setTileEntity", x, y, z, slice.getRenderingBlock());
|
||||
ci.cancel();
|
||||
}
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
package com.gtnewhorizons.angelica.mixins.late.client.starminer;
|
||||
|
||||
import com.gtnewhorizons.angelica.helpers.RendererLivingEntityHelper;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Pseudo;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Redirect;
|
||||
|
||||
@Pseudo
|
||||
@Mixin(targets = "jp.mc.ancientred.starminer.core.TransformClientHelper", remap = false)
|
||||
public class MixinTransformClientHelper {
|
||||
|
||||
@Redirect(
|
||||
method = "rotateCorpseByGravity(Lnet/minecraft/entity/EntityLivingBase;FFF)V",
|
||||
at = @At(
|
||||
value = "INVOKE",
|
||||
target = "Lnet/minecraft/entity/EntityLivingBase;getCommandSenderName()Ljava/lang/String;",
|
||||
remap = true),
|
||||
require = 0)
|
||||
private static String angelica$skipUnusedEntityName(EntityLivingBase entity) {
|
||||
return RendererLivingEntityHelper.getUpsideDownName(entity);
|
||||
}
|
||||
|
||||
@Redirect(
|
||||
method = "rotateCorpseByGravity(Lnet/minecraft/entity/EntityLivingBase;FFF)V",
|
||||
at = @At(
|
||||
value = "INVOKE",
|
||||
target = "Lnet/minecraft/util/EnumChatFormatting;getTextWithoutFormattingCodes(Ljava/lang/String;)Ljava/lang/String;",
|
||||
remap = true),
|
||||
require = 0)
|
||||
private static String angelica$skipUnusedNameFormatting(String entityName) {
|
||||
return RendererLivingEntityHelper.stripFormattingCodes(entityName);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,195 @@
|
||||
package com.gtnewhorizons.angelica.client.font;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLCoreTest;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.testutil.TestPaths;
|
||||
import net.coderbot.iris.uniforms.builtin.BuiltinReplacementUniforms;
|
||||
import org.joml.Matrix4f;
|
||||
import org.joml.Vector4f;
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL13;
|
||||
import org.lwjgl.opengl.GL15;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
@GLCoreTest
|
||||
class FontFilterLightmapGLTest {
|
||||
|
||||
private static final int LIGHTMAP_TEX_UNIT = 1;
|
||||
private static final int LIGHTMAP_SIZE = 16;
|
||||
private static final int VERTEX_SIZE = 36;
|
||||
|
||||
private static final float BRIGHTNESS_X = 128.0f;
|
||||
private static final float BRIGHTNESS_Y = 64.0f;
|
||||
private static final int LIT_TEXEL_X = 8;
|
||||
private static final int LIT_TEXEL_Y = 4;
|
||||
|
||||
private static final int TEXEL_R = 0x40;
|
||||
private static final int TEXEL_G = 0x80;
|
||||
private static final int TEXEL_B = 0xC0;
|
||||
|
||||
private static final int VERTEX_COLOR = 0xFFFFFFFF;
|
||||
|
||||
private int program;
|
||||
private int vao;
|
||||
private int vbo;
|
||||
private int lightmapTexture;
|
||||
|
||||
@AfterEach
|
||||
void cleanup() {
|
||||
GLStateManager.glUseProgram(0);
|
||||
GLStateManager.glBindVertexArray(0);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + LIGHTMAP_TEX_UNIT);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
if (lightmapTexture != 0) { GL11.glDeleteTextures(lightmapTexture); lightmapTexture = 0; }
|
||||
if (vbo != 0) { GLStateManager.glDeleteBuffers(vbo); vbo = 0; }
|
||||
if (vao != 0) { GLStateManager.glDeleteVertexArrays(vao); vao = 0; }
|
||||
if (program != 0) { GLStateManager.glDeleteProgram(program); program = 0; }
|
||||
}
|
||||
|
||||
private static int compile(int type, String name) {
|
||||
final int shader = GLStateManager.glCreateShader(type);
|
||||
GLStateManager.glShaderSource(shader, TestPaths.readString("src/main/resources/assets/angelica/shaders/" + name));
|
||||
GLStateManager.glCompileShader(shader);
|
||||
assertEquals(GL11.GL_TRUE, GLStateManager.glGetShaderi(shader, GL20.GL_COMPILE_STATUS), () -> name + " failed to compile:\n" + GLStateManager.glGetShaderInfoLog(shader, 4096));
|
||||
return shader;
|
||||
}
|
||||
|
||||
private void buildProgram() {
|
||||
final int vertex = compile(GL20.GL_VERTEX_SHADER, "fontFilter.vsh");
|
||||
final int fragment = compile(GL20.GL_FRAGMENT_SHADER, "fontFilter.fsh");
|
||||
program = GLStateManager.glCreateProgram();
|
||||
GLStateManager.glAttachShader(program, vertex);
|
||||
GLStateManager.glAttachShader(program, fragment);
|
||||
GLStateManager.glLinkProgram(program);
|
||||
assertEquals(GL11.GL_TRUE, GLStateManager.glGetProgrami(program, GL20.GL_LINK_STATUS), () -> "fontFilter failed to link:\n" + GLStateManager.glGetProgramInfoLog(program, 4096));
|
||||
GLStateManager.glDeleteShader(vertex);
|
||||
GLStateManager.glDeleteShader(fragment);
|
||||
}
|
||||
|
||||
private void buildLightmapTexture() {
|
||||
final ByteBuffer pixels = BufferUtils.createByteBuffer(LIGHTMAP_SIZE * LIGHTMAP_SIZE * 4);
|
||||
for (int y = 0; y < LIGHTMAP_SIZE; y++) {
|
||||
for (int x = 0; x < LIGHTMAP_SIZE; x++) {
|
||||
final boolean lit = x == LIT_TEXEL_X && y == LIT_TEXEL_Y;
|
||||
final int base = (y * LIGHTMAP_SIZE + x) * 4;
|
||||
pixels.put(base, (byte) (lit ? TEXEL_R : 0));
|
||||
pixels.put(base + 1, (byte) (lit ? TEXEL_G : 0));
|
||||
pixels.put(base + 2, (byte) (lit ? TEXEL_B : 0));
|
||||
pixels.put(base + 3, (byte) 0xFF);
|
||||
}
|
||||
}
|
||||
|
||||
lightmapTexture = GL11.glGenTextures();
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + LIGHTMAP_TEX_UNIT);
|
||||
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, lightmapTexture);
|
||||
GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, LIGHTMAP_SIZE, LIGHTMAP_SIZE, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
}
|
||||
|
||||
private void buildQuad() {
|
||||
vao = GLStateManager.glGenVertexArrays();
|
||||
GLStateManager.glBindVertexArray(vao);
|
||||
|
||||
final ByteBuffer data = BufferUtils.createByteBuffer(3 * VERTEX_SIZE);
|
||||
putVertex(data, -0.9f, -0.9f);
|
||||
putVertex(data, 0.9f, -0.9f);
|
||||
putVertex(data, 0.0f, 0.9f);
|
||||
data.flip();
|
||||
|
||||
vbo = GLStateManager.glGenBuffers();
|
||||
GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
|
||||
GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, data, GL15.GL_STATIC_DRAW);
|
||||
GLStateManager.glEnableVertexAttribArray(0);
|
||||
GLStateManager.glVertexAttribPointer(0, 2, GL11.GL_FLOAT, false, VERTEX_SIZE, 0L);
|
||||
GLStateManager.glEnableVertexAttribArray(1);
|
||||
GLStateManager.glVertexAttribPointer(1, 2, GL11.GL_FLOAT, false, VERTEX_SIZE, 8L);
|
||||
GLStateManager.glEnableVertexAttribArray(2);
|
||||
GLStateManager.glVertexAttribPointer(2, 4, GL11.GL_UNSIGNED_BYTE, true, VERTEX_SIZE, 16L);
|
||||
GLStateManager.glEnableVertexAttribArray(3);
|
||||
GLStateManager.glVertexAttribPointer(3, 4, GL11.GL_FLOAT, false, VERTEX_SIZE, 20L);
|
||||
}
|
||||
|
||||
private static void putVertex(ByteBuffer buf, float x, float y) {
|
||||
final int base = buf.position();
|
||||
buf.putFloat(base, x).putFloat(base + 4, y);
|
||||
buf.putFloat(base + 8, 0.0f).putFloat(base + 12, 0.0f);
|
||||
buf.putInt(base + 16, VERTEX_COLOR);
|
||||
buf.putFloat(base + 20, 0.0f).putFloat(base + 24, 1.0f)
|
||||
.putFloat(base + 28, 0.0f).putFloat(base + 32, 1.0f);
|
||||
buf.position(base + VERTEX_SIZE);
|
||||
}
|
||||
|
||||
private static void applyVanillaLightmapMatrix() {
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + LIGHTMAP_TEX_UNIT);
|
||||
GLStateManager.glMatrixMode(GL11.GL_TEXTURE);
|
||||
GLStateManager.glLoadIdentity();
|
||||
GLStateManager.glScalef(0.00390625f, 0.00390625f, 0.00390625f);
|
||||
GLStateManager.glTranslatef(8.0f, 8.0f, 8.0f);
|
||||
GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
|
||||
}
|
||||
|
||||
private float[] draw(boolean lightmapEnabled) {
|
||||
buildProgram();
|
||||
buildLightmapTexture();
|
||||
buildQuad();
|
||||
applyVanillaLightmapMatrix();
|
||||
|
||||
assertEquals(BuiltinReplacementUniforms.lightmapTextureMatrix, new Matrix4f(GLStateManager.getTextures().getTextureUnitMatrix(LIGHTMAP_TEX_UNIT)), "EntityRenderer#enableLightmap must reproduce the lightmap texture matrix Iris documents");
|
||||
|
||||
final Vector4f uv = new Vector4f(BRIGHTNESS_X, BRIGHTNESS_Y, 0.0f, 1.0f).mul(GLStateManager.getTextures().getTextureUnitMatrix(LIGHTMAP_TEX_UNIT));
|
||||
|
||||
GLStateManager.glViewport(0, 0, 800, 600);
|
||||
GLStateManager.disableDepthTest();
|
||||
GLStateManager.disableCull();
|
||||
GLStateManager.disableBlend();
|
||||
|
||||
GLStateManager.glUseProgram(program);
|
||||
GLStateManager.glUniform1i(GLStateManager.glGetUniformLocation(program, "sampler"), 0);
|
||||
GLStateManager.glUniform1i(GLStateManager.glGetUniformLocation(program, "lightmap"), LIGHTMAP_TEX_UNIT);
|
||||
GLStateManager.glUniform1i(GLStateManager.glGetUniformLocation(program, "aaMode"), 0);
|
||||
GLStateManager.glUniform1f(GLStateManager.glGetUniformLocation(program, "strength"), 1.0f);
|
||||
GLStateManager.glUniform1f(GLStateManager.glGetUniformLocation(program, "alphaTestRef"), 0.0f);
|
||||
GLStateManager.glUniform3f(GLStateManager.glGetUniformLocation(program, "u_Lightmap"), uv.x, uv.y, lightmapEnabled ? 1.0f : 0.0f);
|
||||
|
||||
GLStateManager.glUniformMatrix4(GLStateManager.glGetUniformLocation(program, "u_MVPMatrix"), false, new Matrix4f().get(BufferUtils.createFloatBuffer(16)));
|
||||
|
||||
GLStateManager.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
GLStateManager.glClear(GL11.GL_COLOR_BUFFER_BIT);
|
||||
GLStateManager.glDrawArrays(GL11.GL_TRIANGLES, 0, 3);
|
||||
assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "fontFilter draw must not raise a GL error");
|
||||
|
||||
final ByteBuffer pixel = BufferUtils.createByteBuffer(4);
|
||||
GL11.glReadPixels(400, 200, 1, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixel);
|
||||
return new float[] {
|
||||
(pixel.get(0) & 0xFF) / 255.0f,
|
||||
(pixel.get(1) & 0xFF) / 255.0f,
|
||||
(pixel.get(2) & 0xFF) / 255.0f };
|
||||
}
|
||||
|
||||
@Test
|
||||
void enabledLightmapModulatesTheGlyphColor() {
|
||||
final float[] actual = draw(true);
|
||||
assertEquals(TEXEL_R / 255.0f, actual[0], 2.0f / 255.0f, "red must come from lightmap texel");
|
||||
assertEquals(TEXEL_G / 255.0f, actual[1], 2.0f / 255.0f, "green must come from lightmap texel");
|
||||
assertEquals(TEXEL_B / 255.0f, actual[2], 2.0f / 255.0f, "blue must come from lightmap texel");
|
||||
}
|
||||
|
||||
@Test
|
||||
void disabledLightmapLeavesTheGlyphColorAlone() {
|
||||
final float[] actual = draw(false);
|
||||
assertEquals(1.0f, actual[0], 2.0f / 255.0f, "u_Lightmap.z = 0 must leave the colour unmodulated");
|
||||
assertEquals(1.0f, actual[1], 2.0f / 255.0f, "u_Lightmap.z = 0 must leave the colour unmodulated");
|
||||
assertEquals(1.0f, actual[2], 2.0f / 255.0f, "u_Lightmap.z = 0 must leave the colour unmodulated");
|
||||
}
|
||||
}
|
||||
@@ -18,43 +18,41 @@ class TesrLayerKeyTest {
|
||||
|
||||
@Test
|
||||
void scratchProbeMatchesCopiedKey() {
|
||||
final TesrBatchRenderer.LayerKey scratch = new TesrBatchRenderer.LayerKey().set(TEX, TesrMaterial.Transparency.OPAQUE, true, false, false, false, 0.1f, false, NONE, SHADER, false);
|
||||
final TesrBatchRenderer.LayerKey scratch = new TesrBatchRenderer.LayerKey().set(TEX, TesrMaterial.Transparency.OPAQUE, true, false, false, false, 0.1f, false, NONE, SHADER);
|
||||
final TesrBatchRenderer.LayerKey stored = scratch.copy();
|
||||
assertNotSame(scratch, stored);
|
||||
assertEquals(scratch, stored);
|
||||
assertEquals(scratch.hashCode(), stored.hashCode());
|
||||
|
||||
scratch.set(TEX, TesrMaterial.Transparency.OPAQUE, true, false, false, false, 0.1f, false, NONE, SHADER, false);
|
||||
scratch.set(TEX, TesrMaterial.Transparency.OPAQUE, true, false, false, false, 0.1f, false, NONE, SHADER);
|
||||
assertEquals(stored, scratch, "re-set scratch still matches stored copy");
|
||||
}
|
||||
|
||||
@Test
|
||||
void fieldChangesBreakEquality() {
|
||||
final TesrBatchRenderer.LayerKey base = new TesrBatchRenderer.LayerKey().set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, null, false);
|
||||
final TesrBatchRenderer.LayerKey base = new TesrBatchRenderer.LayerKey().set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, null);
|
||||
final TesrBatchRenderer.LayerKey other = base.copy();
|
||||
|
||||
other.set(null, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, null, false);
|
||||
other.set(null, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, null);
|
||||
assertNotEquals(base, other);
|
||||
other.set(TEX, TesrMaterial.Transparency.TRANSLUCENT, false, false, false, false, 0f, false, NONE, null, false);
|
||||
other.set(TEX, TesrMaterial.Transparency.TRANSLUCENT, false, false, false, false, 0f, false, NONE, null);
|
||||
assertNotEquals(base, other);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0.5f, false, NONE, null, false);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0.5f, false, NONE, null);
|
||||
assertNotEquals(base, other);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, true, 0f, false, NONE, null, false);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, true, 0f, false, NONE, null);
|
||||
assertNotEquals(base, other);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, TesrMaterial.SpecialRender.GLINT, null, false);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, TesrMaterial.SpecialRender.GLINT, null);
|
||||
assertNotEquals(base, other);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, SHADER, false);
|
||||
assertNotEquals(base, other);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, null, true);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, SHADER);
|
||||
assertNotEquals(base, other);
|
||||
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, null, false);
|
||||
other.set(TEX, TesrMaterial.Transparency.OPAQUE, false, false, false, false, 0f, false, NONE, null);
|
||||
assertEquals(base, other);
|
||||
}
|
||||
|
||||
@Test
|
||||
void nullTextureAndShaderHash() {
|
||||
final TesrBatchRenderer.LayerKey key = new TesrBatchRenderer.LayerKey().set(null, null, false, false, false, false, 0f, false, null, null, false);
|
||||
final TesrBatchRenderer.LayerKey key = new TesrBatchRenderer.LayerKey().set(null, null, false, false, false, false, 0f, false, null, null);
|
||||
assertEquals(key, key.copy());
|
||||
assertEquals(key.hashCode(), key.copy().hashCode());
|
||||
}
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
package com.gtnewhorizons.angelica.rendering.tesr;
|
||||
|
||||
import com.gtnewhorizons.angelica.api.tesr.TesrMaterial;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.RenderLayer;
|
||||
import com.gtnewhorizons.angelica.glsm.GLCoreTest;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
@GLCoreTest
|
||||
class TesrLayerStateTest {
|
||||
|
||||
@BeforeEach
|
||||
void liveState() {
|
||||
GLStateManager.disableFog();
|
||||
GLStateManager.enableAlphaTest();
|
||||
GLStateManager.glAlphaFunc(GL11.GL_GREATER, 0.1f);
|
||||
GLStateManager.enableDepthTest();
|
||||
GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
|
||||
GLStateManager.glDepthMask(true);
|
||||
GLStateManager.disableBlend();
|
||||
GLStateManager.enableCull();
|
||||
GLStateManager.enableLighting();
|
||||
}
|
||||
|
||||
private static RenderLayer layer(TesrMaterial material) {
|
||||
return RenderLayer.tesr(null, material);
|
||||
}
|
||||
|
||||
@Test
|
||||
void startDrawingLeavesUndeclaredPhasesToTheSurroundingContext() {
|
||||
layer(TesrMaterial.CURRENT_STATE).startDrawing();
|
||||
|
||||
assertFalse(GLStateManager.getFogMode().isEnabled(), "fog");
|
||||
}
|
||||
|
||||
@Test
|
||||
void endDrawingLeavesUndeclaredPhasesToTheSurroundingContext() {
|
||||
GLStateManager.enableFog();
|
||||
final RenderLayer layer = layer(TesrMaterial.CURRENT_STATE);
|
||||
layer.startDrawing();
|
||||
layer.endDrawing();
|
||||
|
||||
assertTrue(GLStateManager.getFogMode().isEnabled(), "fog");
|
||||
}
|
||||
|
||||
@Test
|
||||
void declaredPhasesApply() {
|
||||
layer(TesrMaterial.CURRENT_STATE).startDrawing();
|
||||
|
||||
assertFalse(GLStateManager.getAlphaTest().isEnabled(), "ZERO_ALPHA");
|
||||
assertTrue(GLStateManager.getDepthTest().isEnabled(), "LEQUAL_DEPTH_TEST");
|
||||
assertEquals(GL11.GL_LEQUAL, GLStateManager.getDepthState().getFunc());
|
||||
assertFalse(GLStateManager.getBlendMode().isEnabled(), "NO_TRANSPARENCY");
|
||||
assertEquals(GL11.GL_SMOOTH, GLStateManager.getShadeModelState().getValue(), "SMOOTH_SHADE_MODEL");
|
||||
}
|
||||
|
||||
@Test
|
||||
void everyMaterialToggleApplies() {
|
||||
final TesrMaterial material = TesrMaterial.builder().noCull().unlit().noDepthWrite().cutout(0.5f).translucent().depthEqual().build();
|
||||
layer(material).startDrawing();
|
||||
|
||||
assertFalse(GLStateManager.getCullState().isEnabled(), "noCull");
|
||||
assertFalse(GLStateManager.getLightingState().isEnabled(), "unlit");
|
||||
assertFalse(GLStateManager.getDepthState().isEnabled(), "noDepthWrite");
|
||||
assertTrue(GLStateManager.getAlphaTest().isEnabled(), "cutout");
|
||||
assertEquals(0.5f, GLStateManager.getAlphaState().getReference(), "cutout threshold");
|
||||
assertTrue(GLStateManager.getBlendMode().isEnabled(), "translucent");
|
||||
assertEquals(GL11.GL_SRC_ALPHA, GLStateManager.getBlendState().getSrcRgb());
|
||||
assertEquals(GL11.GL_ONE_MINUS_SRC_ALPHA, GLStateManager.getBlendState().getDstRgb());
|
||||
assertEquals(GL11.GL_EQUAL, GLStateManager.getDepthState().getFunc(), "depthEqual");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
package com.gtnewhorizons.angelica.utils;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertSame;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraft.world.ChunkPosition;
|
||||
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.world.WorldSlice;
|
||||
|
||||
class ConcurrentTileEntityMapTest {
|
||||
|
||||
private static final ChunkPosition POS = new ChunkPosition(1, 2, 3);
|
||||
|
||||
private final ConcurrentTileEntityMap map = new ConcurrentTileEntityMap();
|
||||
|
||||
@AfterEach
|
||||
void leaveWorkerContext() {
|
||||
RenderThreadContext.clear();
|
||||
}
|
||||
|
||||
private static void enterWorkerContext() {
|
||||
RenderThreadContext.set(mock(WorldSlice.class));
|
||||
}
|
||||
|
||||
private static TileEntity tileEntity(boolean invalid) {
|
||||
final TileEntity te = mock(TileEntity.class);
|
||||
when(te.isInvalid()).thenReturn(invalid);
|
||||
return te;
|
||||
}
|
||||
|
||||
@Test
|
||||
void containsKeyAgreesWithGetForAnInvalidTileEntityOnAWorker() {
|
||||
map.put(POS, tileEntity(true));
|
||||
enterWorkerContext();
|
||||
|
||||
assertNull(map.get(POS), "get must hide an invalid tile entity from a worker");
|
||||
assertFalse(map.containsKey(POS), "containsKey must agree with get");
|
||||
}
|
||||
|
||||
@Test
|
||||
void containsKeyAgreesWithGetForAValidTileEntityOnAWorker() {
|
||||
final TileEntity te = tileEntity(false);
|
||||
map.put(POS, te);
|
||||
enterWorkerContext();
|
||||
|
||||
assertSame(te, map.get(POS));
|
||||
assertTrue(map.containsKey(POS));
|
||||
}
|
||||
|
||||
@Test
|
||||
void containsKeyReportsInvalidTileEntitiesOnTheClientThread() {
|
||||
map.put(POS, tileEntity(true));
|
||||
|
||||
assertTrue(map.containsKey(POS), "the client thread owns invalidation and must still see the entry");
|
||||
}
|
||||
|
||||
@Test
|
||||
void removeFromAWorkerDefersInsteadOfMutating() {
|
||||
final TileEntity te = tileEntity(false);
|
||||
map.put(POS, te);
|
||||
enterWorkerContext();
|
||||
|
||||
assertNull(map.remove(POS));
|
||||
assertEquals(1, map.size(), "a worker must not mutate the map");
|
||||
|
||||
RenderThreadContext.clear();
|
||||
assertSame(te, map.get(POS), "a valid tile entity survives a deferred invalidation");
|
||||
}
|
||||
|
||||
@Test
|
||||
void deferredInvalidationEvictsOnTheNextClientThreadWrite() {
|
||||
map.put(POS, tileEntity(true));
|
||||
enterWorkerContext();
|
||||
map.get(POS);
|
||||
RenderThreadContext.clear();
|
||||
|
||||
map.put(new ChunkPosition(4, 5, 6), tileEntity(false));
|
||||
|
||||
assertFalse(map.containsKey(POS));
|
||||
}
|
||||
}
|
||||
+79
-25
@@ -4,6 +4,7 @@ import com.gtnewhorizons.angelica.config.SystemProperties;
|
||||
import com.gtnewhorizons.angelica.glsm.backend.BackendManager;
|
||||
import com.gtnewhorizons.angelica.glsm.backend.RenderBackend;
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.TracyBackend;
|
||||
import com.gtnewhorizons.angelica.glsm.profiling.ZoneStack;
|
||||
import me.eigenraven.lwjgl3ify.api.Lwjgl3Aware;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
@@ -18,12 +19,12 @@ import org.lwjgl.system.libffi.FFIType;
|
||||
import org.lwjgl.system.libffi.LibFFI;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.DoubleBuffer;
|
||||
import java.nio.LongBuffer;
|
||||
import java.util.concurrent.ConcurrentLinkedQueue;
|
||||
|
||||
import static org.lwjgl.system.MemoryStack.stackPush;
|
||||
import static org.lwjgl.system.MemoryUtil.NULL;
|
||||
import static org.lwjgl.system.MemoryUtil.memAddress;
|
||||
import static org.lwjgl.system.MemoryUtil.memGetInt;
|
||||
import static org.lwjgl.system.MemoryUtil.memPutAddress;
|
||||
import static org.lwjgl.system.MemoryUtil.memPutByte;
|
||||
import static org.lwjgl.system.MemoryUtil.memPutInt;
|
||||
@@ -33,12 +34,16 @@ import static org.lwjgl.system.MemoryUtil.nmemAllocChecked;
|
||||
public final class TracyClientBackend implements TracyBackend {
|
||||
private static final Logger LOGGER = LogManager.getLogger("Tracy");
|
||||
private static final int MAX_TEXT = 8192;
|
||||
private static final int ACTIVE_OFFSET = 4;
|
||||
|
||||
private SharedLibrary lib;
|
||||
private TracyLibrary sym;
|
||||
private SrcLocInterner interner;
|
||||
private long emptyString;
|
||||
private FFICIF plotCif;
|
||||
private int ctxSize;
|
||||
int zoneCtxSize() {
|
||||
return ctxSize;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean init() {
|
||||
@@ -52,18 +57,15 @@ public final class TracyClientBackend implements TracyBackend {
|
||||
sym = TracyLibrary.resolve(lib);
|
||||
if (sym == null) return false;
|
||||
|
||||
emptyString = nmemAllocChecked(1);
|
||||
memPutByte(emptyString, (byte) 0);
|
||||
|
||||
final PointerBuffer plotArgTypes = MemoryUtil.memAllocPointer(2);
|
||||
plotArgTypes.put(0, LibFFI.ffi_type_pointer.address()).put(1, LibFFI.ffi_type_double.address());
|
||||
plotCif = FFICIF.malloc();
|
||||
final int status = LibFFI.ffi_prep_cif(plotCif, LibFFI.FFI_DEFAULT_ABI, LibFFI.ffi_type_void, plotArgTypes);
|
||||
if (status != LibFFI.FFI_OK) {
|
||||
LOGGER.warn("Tracy: ffi_prep_cif failed: {}", status);
|
||||
ctxSize = (int) JNI.invokeJ(sym.zoneCtxSize);
|
||||
if (ctxSize <= 0 || Integer.bitCount(ctxSize) != 1) {
|
||||
LOGGER.warn("Tracy: zone context size {} is not a power of two; slot addressing would be wrong", ctxSize);
|
||||
return false;
|
||||
}
|
||||
|
||||
emptyString = nmemAllocChecked(1);
|
||||
memPutByte(emptyString, (byte) 0);
|
||||
|
||||
interner = new SrcLocInterner(this::allocSrcLoc, SystemProperties.TRACY_MAX_SRC_LOCS);
|
||||
|
||||
JNI.invokeV(sym.startupProfiler);
|
||||
@@ -101,26 +103,64 @@ public final class TracyClientBackend implements TracyBackend {
|
||||
return interner.dynamicSrcLoc();
|
||||
}
|
||||
|
||||
private static final ConcurrentLinkedQueue<SlotArena> ARENAS = new ConcurrentLinkedQueue<>();
|
||||
|
||||
private static final class SlotArena {
|
||||
private final long base;
|
||||
private final int strideShift;
|
||||
private int depth;
|
||||
|
||||
SlotArena(int stride) {
|
||||
this.strideShift = Integer.numberOfTrailingZeros(stride);
|
||||
this.base = nmemAllocChecked((long) stride * ZoneStack.MAX_DEPTH);
|
||||
}
|
||||
|
||||
long top() {
|
||||
return depth == ZoneStack.MAX_DEPTH ? NULL : base + ((long) depth << strideShift);
|
||||
}
|
||||
|
||||
void unwindTo(long slot) {
|
||||
final long index = (slot - base) >> strideShift;
|
||||
if (index >= 0 && index < ZoneStack.MAX_DEPTH) depth = (int) index;
|
||||
}
|
||||
}
|
||||
|
||||
private final ThreadLocal<SlotArena> slots = ThreadLocal.withInitial(() -> {
|
||||
final SlotArena arena = new SlotArena(ctxSize);
|
||||
ARENAS.add(arena);
|
||||
return arena;
|
||||
});
|
||||
|
||||
@Override
|
||||
public long beginZone(long srcLoc) {
|
||||
return JNI.invokePJ(srcLoc, 1, sym.zoneBegin);
|
||||
final SlotArena arena = slots.get();
|
||||
final long slot = arena.top();
|
||||
if (slot == NULL) return 0L;
|
||||
JNI.invokePPV(srcLoc, 1, slot, sym.zoneBegin);
|
||||
if (memGetInt(slot + ACTIVE_OFFSET) == 0) return 0L;
|
||||
arena.depth++;
|
||||
return slot;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void endZone(long ctx) {
|
||||
JNI.invokeJV(ctx, sym.zoneEnd);
|
||||
if (ctx == 0L) return;
|
||||
slots.get().unwindTo(ctx);
|
||||
JNI.invokePV(ctx, sym.zoneEnd);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void zoneText(long ctx, String text) {
|
||||
if (ctx == 0L) return;
|
||||
try (MemoryStack stack = stackPush()) {
|
||||
final ByteBuffer utf8 = stack.UTF8(truncate(text), false);
|
||||
JNI.invokeJPPV(ctx, memAddress(utf8), utf8.remaining(), sym.zoneText);
|
||||
JNI.invokePPPV(ctx, memAddress(utf8), utf8.remaining(), sym.zoneText);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void zoneValue(long ctx, long value) {
|
||||
if (ctx == 0L) return;
|
||||
JNI.invokePJV(ctx, value, sym.zoneValue);
|
||||
}
|
||||
|
||||
@@ -153,19 +193,33 @@ public final class TracyClientBackend implements TracyBackend {
|
||||
|
||||
@Override
|
||||
public void plot(long namePtr, double value) {
|
||||
JNI.invokePJV(namePtr, Double.doubleToRawLongBits(value), sym.plot);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void message(String text, int severity) {
|
||||
try (MemoryStack stack = stackPush()) {
|
||||
final LongBuffer arg0 = stack.longs(namePtr);
|
||||
final DoubleBuffer arg1 = stack.doubles(value);
|
||||
final PointerBuffer args = stack.pointers(memAddress(arg0), memAddress(arg1));
|
||||
LibFFI.ffi_call(plotCif, sym.plot, null, args);
|
||||
final ByteBuffer utf8 = stack.UTF8(truncate(text), false);
|
||||
JNI.invokePPV(severity, 0, 0, (long) utf8.remaining(), memAddress(utf8), sym.message);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void message(String text) {
|
||||
public long sectionEnter(int category, String text) {
|
||||
try (MemoryStack stack = stackPush()) {
|
||||
final ByteBuffer utf8 = stack.UTF8(truncate(text), false);
|
||||
JNI.invokePPV(memAddress(utf8), (long) utf8.remaining(), 0, sym.message);
|
||||
return Integer.toUnsignedLong(JNI.invokePI(category, memAddress(stack.UTF8(truncate(text), true)), sym.sectionEnter));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sectionLeave(long id) {
|
||||
JNI.invokeV((int) id, sym.sectionLeave);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sectionSetup(int category, String name) {
|
||||
try (MemoryStack stack = stackPush()) {
|
||||
JNI.invokePV(category, memAddress(stack.UTF8(truncate(name), true)), sym.sectionSetup);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -191,15 +245,15 @@ public final class TracyClientBackend implements TracyBackend {
|
||||
@Override
|
||||
public void shutdown() {
|
||||
JNI.invokeV(sym.shutdownProfiler);
|
||||
for (SlotArena arena = ARENAS.poll(); arena != null; arena = ARENAS.poll()) {
|
||||
MemoryUtil.nmemFree(arena.base);
|
||||
}
|
||||
}
|
||||
|
||||
private static String truncate(String text) {
|
||||
return text.length() > MAX_TEXT ? text.substring(0, MAX_TEXT) : text;
|
||||
}
|
||||
|
||||
/*
|
||||
* GPU zones: port of TracyOpenGL.hpp GpuCtx (v0.13.1).
|
||||
*/
|
||||
private static final int GPU_QUERY_COUNT = 16 * 1024;
|
||||
private static final byte GPU_CONTEXT_ID = 0;
|
||||
private static final byte GPU_CONTEXT_TYPE_OPENGL = 1;
|
||||
|
||||
@@ -11,6 +11,7 @@ import static org.lwjgl.system.MemoryUtil.NULL;
|
||||
final class TracyLibrary {
|
||||
private static final Logger LOGGER = LogManager.getLogger("Tracy");
|
||||
|
||||
final long zoneCtxSize;
|
||||
final long startupProfiler;
|
||||
final long shutdownProfiler;
|
||||
final long profilerStarted;
|
||||
@@ -26,6 +27,9 @@ final class TracyLibrary {
|
||||
final long message;
|
||||
final long messageAppinfo;
|
||||
final long setThreadName;
|
||||
final long sectionEnter;
|
||||
final long sectionLeave;
|
||||
final long sectionSetup;
|
||||
final long gpuZoneBegin;
|
||||
final long gpuZoneEnd;
|
||||
final long gpuTime;
|
||||
@@ -43,21 +47,25 @@ final class TracyLibrary {
|
||||
}
|
||||
|
||||
private TracyLibrary(SharedLibrary lib) {
|
||||
zoneCtxSize = req(lib, "ang_zone_ctx_size");
|
||||
startupProfiler = req(lib, "___tracy_startup_profiler");
|
||||
shutdownProfiler = req(lib, "___tracy_shutdown_profiler");
|
||||
profilerStarted = req(lib, "___tracy_profiler_started");
|
||||
connected = req(lib, "___tracy_connected");
|
||||
zoneBegin = req(lib, "___tracy_emit_zone_begin");
|
||||
zoneEnd = req(lib, "___tracy_emit_zone_end");
|
||||
zoneText = req(lib, "___tracy_emit_zone_text");
|
||||
zoneValue = req(lib, "___tracy_emit_zone_value");
|
||||
zoneBegin = req(lib, "ang_zone_begin");
|
||||
zoneEnd = req(lib, "ang_zone_end");
|
||||
zoneText = req(lib, "ang_zone_text");
|
||||
zoneValue = req(lib, "ang_zone_value");
|
||||
frameMark = req(lib, "___tracy_emit_frame_mark");
|
||||
plot = req(lib, "___tracy_emit_plot");
|
||||
plot = req(lib, "ang_plot");
|
||||
plotInt = req(lib, "___tracy_emit_plot_int");
|
||||
plotConfig = req(lib, "___tracy_emit_plot_config");
|
||||
message = req(lib, "___tracy_emit_message");
|
||||
message = req(lib, "___tracy_emit_logString");
|
||||
messageAppinfo = req(lib, "___tracy_emit_message_appinfo");
|
||||
setThreadName = req(lib, "___tracy_set_thread_name");
|
||||
sectionEnter = req(lib, "ang_section_enter");
|
||||
sectionLeave = req(lib, "ang_section_leave");
|
||||
sectionSetup = req(lib, "ang_section_setup");
|
||||
gpuZoneBegin = req(lib, "___tracy_emit_gpu_zone_begin");
|
||||
gpuZoneEnd = req(lib, "___tracy_emit_gpu_zone_end");
|
||||
gpuTime = req(lib, "___tracy_emit_gpu_time");
|
||||
|
||||
@@ -47,7 +47,7 @@ final class TracyNativeLoader {
|
||||
case MACOS -> "libTracyClient.dylib";
|
||||
case LINUX -> "libTracyClient.so";
|
||||
};
|
||||
final String resource = "/natives/tracy/" + platform + "/" + libName;
|
||||
final String resource = "/natives/tracy/" + TRACY_VERSION + "/" + platform + "/" + libName;
|
||||
|
||||
final byte[] lib;
|
||||
try (InputStream in = TracyNativeLoader.class.getResourceAsStream(resource)) {
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
cmake_minimum_required(VERSION 3.13)
|
||||
project(angelica-tracy-native CXX)
|
||||
|
||||
if(NOT DEFINED TRACY_SRC_DIR)
|
||||
message(FATAL_ERROR "TRACY_SRC_DIR must be set to a Tracy source checkout")
|
||||
endif()
|
||||
|
||||
add_subdirectory("${TRACY_SRC_DIR}" tracy)
|
||||
|
||||
target_sources(TracyClient PRIVATE "${CMAKE_CURRENT_LIST_DIR}/angelica_tracy_shim.cpp")
|
||||
target_include_directories(TracyClient PRIVATE "${TRACY_SRC_DIR}/public")
|
||||
@@ -0,0 +1,53 @@
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
|
||||
#include "tracy/TracyC.h"
|
||||
#include "client/TracyProfiler.hpp"
|
||||
#include "common/TracyApi.h"
|
||||
|
||||
|
||||
static_assert(offsetof(TracyCZoneCtx, active) == 4, "TracyClientBackend.ACTIVE_OFFSET reads the active flag at a fixed offset of 4");
|
||||
|
||||
// Shim to cover things not reachable, or not efficiently usable, from Java; including header-inlined functions.
|
||||
extern "C" {
|
||||
|
||||
TRACY_API uint64_t ang_zone_ctx_size(void) {
|
||||
return (uint64_t)sizeof(TracyCZoneCtx);
|
||||
}
|
||||
|
||||
TRACY_API void ang_zone_begin(const struct ___tracy_source_location_data* srcloc, int32_t active, void* out) {
|
||||
*(TracyCZoneCtx*)out = ___tracy_emit_zone_begin(srcloc, active);
|
||||
}
|
||||
|
||||
TRACY_API void ang_zone_end(const void* ctx) {
|
||||
___tracy_emit_zone_end(*(const TracyCZoneCtx*)ctx);
|
||||
}
|
||||
|
||||
TRACY_API void ang_zone_text(const void* ctx, const char* txt, uint64_t size) {
|
||||
___tracy_emit_zone_text(*(const TracyCZoneCtx*)ctx, txt, (size_t)size);
|
||||
}
|
||||
|
||||
TRACY_API void ang_zone_value(const void* ctx, uint64_t value) {
|
||||
___tracy_emit_zone_value(*(const TracyCZoneCtx*)ctx, value);
|
||||
}
|
||||
|
||||
TRACY_API void ang_plot(const char* name, int64_t valueBits) {
|
||||
double value;
|
||||
memcpy(&value, &valueBits, sizeof(value));
|
||||
___tracy_emit_plot(name, value);
|
||||
}
|
||||
|
||||
TRACY_API uint32_t ang_section_enter(uint32_t category, const char* txt) {
|
||||
return tracy::Profiler::SectionEnter((uint16_t)category, "%s", txt);
|
||||
}
|
||||
|
||||
TRACY_API void ang_section_leave(uint32_t id) {
|
||||
tracy::Profiler::SectionLeave(id);
|
||||
}
|
||||
|
||||
TRACY_API void ang_section_setup(uint32_t category, const char* txt) {
|
||||
tracy::Profiler::SectionSetup((uint16_t)category, "%s", txt);
|
||||
}
|
||||
|
||||
}
|
||||
+24
-6
@@ -34,7 +34,7 @@ class TracyBindingSmokeTest {
|
||||
static boolean nativePresent() {
|
||||
for (String platform : new String[] {"windows-x64", "linux-x64", "macos-x64", "macos-arm64"}) {
|
||||
for (String lib : new String[] {"TracyClient.dll", "libTracyClient.so", "libTracyClient.dylib"}) {
|
||||
if (TracyBindingSmokeTest.class.getResource("/natives/tracy/" + platform + "/" + lib) != null) {
|
||||
if (TracyBindingSmokeTest.class.getResource("/natives/tracy/" + TracyTags.TRACY_VERSION + "/" + platform + "/" + lib) != null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -57,8 +57,26 @@ class TracyBindingSmokeTest {
|
||||
return backend;
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(0)
|
||||
void nativeIsBuiltWithOnDemand() throws Exception {
|
||||
assertEquals(16, backend().zoneCtxSize(), "ctx size is 16 only with TRACY_ON_DEMAND");
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(1)
|
||||
void zeroHandlesAreInertWhileDisconnected() throws Exception {
|
||||
final TracyClientBackend b = backend();
|
||||
assertEquals(0L, b.beginZone(b.internSrcLoc("disconnected", 0)), "zone must be inactive with no profiler attached");
|
||||
b.endZone(0L);
|
||||
b.zoneText(0L, "text");
|
||||
b.zoneValue(0L, 1L);
|
||||
assertEquals(0L, b.sectionEnter(1, "disconnected section"));
|
||||
b.sectionLeave(0L);
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(2)
|
||||
void internAndSingleZone() throws Exception {
|
||||
final TracyClientBackend b = backend();
|
||||
final long srcLoc = b.internSrcLoc("smoke", 0);
|
||||
@@ -72,7 +90,7 @@ class TracyBindingSmokeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(2)
|
||||
@Order(3)
|
||||
void hammerZonesAcrossThreads() throws Exception {
|
||||
final TracyClientBackend b = backend();
|
||||
final int threads = 4;
|
||||
@@ -108,7 +126,7 @@ class TracyBindingSmokeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(3)
|
||||
@Order(4)
|
||||
void plotsMessagesAndFrameMarks() throws Exception {
|
||||
final TracyClientBackend b = backend();
|
||||
final long plotName = b.internPlotName("smokePlot", 0);
|
||||
@@ -126,7 +144,7 @@ class TracyBindingSmokeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(4)
|
||||
@Order(5)
|
||||
void dynamicSrcLocOverflowPath() throws Exception {
|
||||
final TracyClientBackend b = backend();
|
||||
final long dynamic = b.dynamicSrcLoc();
|
||||
@@ -137,7 +155,7 @@ class TracyBindingSmokeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(5)
|
||||
@Order(6)
|
||||
void gpuEmitStructMarshalling() throws Exception {
|
||||
final TracyClientBackend b = backend();
|
||||
final long srcLoc = b.internSrcLoc("gpu-smoke", 0);
|
||||
@@ -152,7 +170,7 @@ class TracyBindingSmokeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@Order(6)
|
||||
@Order(7)
|
||||
void shutdownFlushes() throws Exception {
|
||||
backend().shutdown();
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user