- Internal GLSL brightness shader, so gamma control can work without the glsl/brightness_fp.glsl file when r_ext_vertex_shader is 1 and r_alternateBrightness is 2.

leilei- · leilei- · commit 8b7378a4be6c · 2025-05-17T05:03:54.000-04:00
- r_skyTess - an attempt to make the complexity of skydomes an option so it could use less polygons. Has no effect on skyboxes
diff --git a/code/renderer_oa/tr_init.c b/code/renderer_oa/tr_init.c
@@ -213,6 +213,8 @@ cvar_t	*r_leifx;		// Leilei - leifx nostalgia filter
 cvar_t	*r_shadeMethod;		// Leilei
 cvar_t	*r_particles;		// Leilei - particle effects motif
 
+cvar_t	*r_skytess;	// leilei - lower detail of skies
+
 cvar_t	*r_leidebug;		// Leilei - debug
 cvar_t	*r_leidebugeye;		// Leilei - eye debug
 
@@ -1293,6 +1295,9 @@ void R_Register( void )
 	r_mockvr = ri.Cvar_Get( "r_mockvr", "0" , CVAR_CHEAT);
 	r_leifx = ri.Cvar_Get( "r_leifx", "0" , CVAR_ARCHIVE | CVAR_LATCH);
 	r_shadeMethod = ri.Cvar_Get( "r_shadeMethod", "0" , CVAR_ARCHIVE);		// leilei - Alternative lightingDiffuse
+
+	r_skytess = ri.Cvar_Get( "r_skyTess", "8", CVAR_ARCHIVE );			// leilei - sky detail adjustment
+
 	r_detailTextureScale = ri.Cvar_Get( "r_detailtextureScale", "0", CVAR_ARCHIVE | CVAR_LATCH ); // leilei - adjust scale of detail textures
 	r_detailTextureLayers = ri.Cvar_Get( "r_detailtextureLayers", "0", CVAR_ARCHIVE | CVAR_LATCH ); // leilei - add more detail layers
 
@@ -1449,7 +1454,56 @@ void R_GLSL_Init(void)
 
 	Q_strncpyz(programVertexObjects[0], "glsl/brightness_vp.glsl", sizeof(programVertexObjects[0]));
 	Q_strncpyz(programFragmentObjects[0], "glsl/brightness_fp.glsl", sizeof(programFragmentObjects[0]));
-	tr.BrightnessProgram = RE_GLSL_RegisterProgram("brightness", (const char *)programVertexObjects, 1, (const char *)programFragmentObjects, 1);
+	if (!(tr.BrightnessProgram = RE_GLSL_RegisterProgram("brightness", (const char *)programVertexObjects, 1, (const char *)programFragmentObjects, 1)))
+	{
+		// load it through this code
+	ri.Printf( PRINT_ALL, "----- Trying to load Brightness Shader internally!!! \n" );
+
+		const GLchar *brightnessfp = \	
+			"#version 120 \n"
+			"uniform sampler2D u_Texture0; \n"
+			"varying vec2 texture_coordinate;\n"
+			"uniform float u_CC_Overbright; \n"
+			"uniform float u_CC_Gamma; \n"
+			"void main()\n"
+			"{\n"
+    			"gl_FragColor = texture2D(u_Texture0, texture_coordinate); \n"
+			"vec3 color;\n"
+			"vec3 colord;\n"
+			"int coloredr;\n"
+			"int coloredg;\n"
+			"int coloredb;\n"
+			"color.r = 1;\n"
+			"color.g = 1;\n"
+			"color.b = 1;\n"
+			"int yeh = 0;\n"
+			"float ohyes;\n"
+			"// Overbrights\n"
+    			"gl_FragColor *= (u_CC_Overbright + 1);\n"
+			"// Gamma Correction\n"
+			"float gamma = u_CC_Gamma;\n"
+			"gl_FragColor.r = pow(gl_FragColor.r, 1.0 / gamma);\n"
+			"gl_FragColor.g = pow(gl_FragColor.g, 1.0 / gamma);\n"
+			"gl_FragColor.b = pow(gl_FragColor.b, 1.0 / gamma);\n"
+			"}\n";
+
+		const GLchar *brightnessvp = \
+			"varying vec2 texture_coordinate;\n"
+			"varying vec2 texture_coordinate2;\n"
+			"varying vec2 texture_coordinate3;\n"
+			"varying vec2 texture_coordinate4;\n"
+			"varying vec2 texture_coordinate5;\n"
+			"varying float scale;\n"
+			"uniform float u_CC_Overbright;\n"
+			"uniform float u_CC_Gamma;\n"
+			"void main()\n"
+			"{\n"
+	    		"gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; \n"
+	    		"texture_coordinate = vec2(gl_MultiTexCoord0); \n"
+			"}\n";
+
+			tr.BrightnessProgram = RE_GLSL_RegisterProgramRaw("brightnessInternal", (const char *)brightnessvp, 1, (const char *)brightnessfp, 1);
+	}
 
 	if (strcmp( (const char *)r_postprocess->string, "none" )) {
 		sprintf(p,"glsl/%s_vp.glsl",r_postprocess->string);
diff --git a/code/renderer_oa/tr_local.h b/code/renderer_oa/tr_local.h
@@ -1402,6 +1402,8 @@ extern  cvar_t	*r_detailTextureLayers;		// leilei - add in more smaller detail t
 
 extern  cvar_t	*r_textureDither;		// leilei - apply dithering for lower texture bits
 
+extern cvar_t	*r_skytess;		// leilei - adjusts the subdivisions of the sky (max 8, min 1)
+
 //====================================================================
 
 void R_SwapBuffers( int );
@@ -1948,6 +1950,7 @@ static ID_INLINE void R_GLSL_SetUniform_rubyOutputSize(glslProgram_t *program, c
 
 void R_GLSL_Init(void);
 qhandle_t RE_GLSL_RegisterProgram(const char *name, const char *programVertexObjects, int numVertexObjects, const char *programFragmentObjects, int numFragmentObjects);
+qhandle_t RE_GLSL_RegisterProgramRaw(const char *name, const char *programVertexObjects, int numVertexObjects, const char *programFragmentObjects, int numFragmentObjects);
 void R_GLSL_UseProgram(qhandle_t index);
 void RB_GLSL_StageIteratorGeneric(void);
 void RB_GLSL_StageIteratorVertexLitTexture(void);
diff --git a/code/renderer_oa/tr_shader.c b/code/renderer_oa/tr_shader.c
@@ -456,6 +456,137 @@ static qboolean R_GLSL_LoadProgram(glslProgram_t *program, const char *name, con
 #endif
 }
 
+static qboolean R_GLSL_LoadProgramRaw(glslProgram_t *program, const char *name, const char *programVertexObjects, int numVertexObjects, const char *programFragmentObjects, int numFragmentObjects) {
+#ifdef GLSL_BACKEND
+	GLcharARB		*buffer_vp[MAX_PROGRAM_OBJECTS];
+	GLcharARB		*buffer_fp[MAX_PROGRAM_OBJECTS];
+	GLcharARB		*buffer;
+	GLhandleARB		shader_vp;
+	GLhandleARB		shader_fp;
+	GLint			status;
+	char			*str;
+	int				size = 0;
+	int				i;
+
+
+	/* create program */
+	program->program = qglCreateProgramObjectARB();
+
+	/* vertex program */
+	for (i = 0, str = (const char *)programVertexObjects; i < numVertexObjects; i++, str += MAX_QPATH) {
+		buffer_vp[i] = str;
+		size += sizeof(str)*32;
+		if (!buffer_vp[i]) {
+			ri.Printf( PRINT_WARNING,  "Couldn't load %s", str);
+			return qfalse;
+		}
+
+		/* compile vertex shader */
+		shader_vp = qglCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
+		qglShaderSourceARB(shader_vp, 1, (const GLcharARB **)&buffer_vp, NULL);
+		qglCompileShaderARB(shader_vp);
+
+		/* check for errors in vertex shader */
+		qglGetObjectParameterivARB(shader_vp, GL_OBJECT_COMPILE_STATUS_ARB, &status);
+		if (!status) {
+			int		length;
+			char	*msg;
+
+			/* print glsl error message */
+			qglGetObjectParameterivARB(shader_vp, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+			msg = ri.Hunk_AllocateTempMemory(length);
+			qglGetInfoLogARB(shader_vp, length, &length, msg);
+			ri.Printf(PRINT_ALL, "Error:\n%s\n", msg);
+			ri.Hunk_FreeTempMemory(msg);
+
+			/* exit */
+			ri.Printf( PRINT_WARNING,  "Couldn't compile vertex shader for program %s", name);
+			return qfalse;
+		}
+
+		/* attach vertex shader to program */
+		qglAttachObjectARB(program->program, shader_vp);
+		qglDeleteObjectARB(shader_vp);
+	}
+
+	/* fragment program */
+	for (i = 0, str = (const char *)programFragmentObjects; i < numFragmentObjects; i++, str += MAX_QPATH) {
+		buffer_fp[i] = str;
+		size += sizeof(str)*32;
+		if (!buffer_fp[i]) {
+			ri.Printf( PRINT_WARNING,  "Couldn't load %s", str);
+			return qfalse;
+		}
+
+		/* compile fragment shader */
+		shader_fp = qglCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
+		qglShaderSourceARB(shader_fp, 1, (const GLcharARB **)&buffer_fp[i], NULL);
+		qglCompileShaderARB(shader_fp);
+
+		/* check for errors in fragment shader */
+		qglGetObjectParameterivARB(shader_fp, GL_OBJECT_COMPILE_STATUS_ARB, &status);
+		if (!status) {
+			int		length;
+			char	*msg;
+
+			/* print glsl error message */
+
+			qglGetObjectParameterivARB(shader_fp, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+			msg = ri.Hunk_AllocateTempMemory(length);
+			qglGetInfoLogARB(shader_fp, length, &length, msg);
+			ri.Printf(PRINT_ALL, "Error:\n%s\n", msg);
+			ri.Hunk_FreeTempMemory(msg);
+			ri.Printf(PRINT_DEVELOPER, "oops\n");
+			/* exit */
+			ri.Printf( PRINT_WARNING,  "Couldn't compile fragment shader for program %s", name);
+			return qfalse;
+		}
+
+		/* attach fragment shader to program */
+		qglAttachObjectARB(program->program, shader_fp);
+		qglDeleteObjectARB(shader_fp);
+	}
+
+	/* link complete program */
+	qglLinkProgramARB(program->program);
+	/* check for linking errors */
+	qglGetObjectParameterivARB(program->program, GL_OBJECT_LINK_STATUS_ARB, &status);
+	if (!status) {
+		int		length;
+		char	*msg;
+		/* print glsl error message */
+		qglGetObjectParameterivARB(program->program, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+		msg = ri.Hunk_AllocateTempMemory(length);
+		qglGetInfoLogARB(program->program, length, &length, msg);
+		ri.Printf(PRINT_ALL, "Error:\n%s\n", msg);
+		ri.Hunk_FreeTempMemory(msg);
+
+		/* exit */
+		ri.Printf( PRINT_WARNING,  "Couldn't link shaders for program %s", name);
+		return qfalse;
+	}
+	/* build single large program file for parsing */
+	buffer = ri.Hunk_AllocateTempMemory(++size);
+
+	Q_strncpyz(buffer, buffer_vp[0], size);
+
+	for (i = 1; i < numVertexObjects; i++)
+		strncat(buffer, buffer_vp[i], size);
+	for (i = 0; i < numFragmentObjects; i++)
+		strncat(buffer, buffer_fp[i], size);
+	/* get uniform locations */
+	qglUseProgramObjectARB(program->program);
+	R_GLSL_ParseProgram(program, buffer);
+	qglUseProgramObjectARB(0);
+	/* clean up */
+	ri.Hunk_FreeTempMemory(buffer);
+
+	return qtrue;
+#endif
+}
+
+
+
 /*
  * RE_GLSL_RegisterProgram
  * Loads in a program of given name
@@ -514,6 +645,65 @@ qhandle_t RE_GLSL_RegisterProgram(const char *name, const char *programVertexObj
 }
 
 
+/*
+ * RE_GLSL_RegisterProgram
+ * Loads in a program of given name
+ */
+qhandle_t RE_GLSL_RegisterProgramRaw(const char *name, const char *programVertexObjects, int numVertexObjects, const char *programFragmentObjects, int numFragmentObjects) {
+#ifdef GLSL_BACKEND
+	glslProgram_t	*program;
+	qhandle_t		hProgram;
+
+	if (!vertexShaders)
+			return 0;
+
+	if (!name || !name[0]) {
+		ri.Printf(PRINT_ALL, "RE_GLSL_RegisterProgram: NULL name\n");
+		return 0;
+	}
+
+	if (strlen(name) >= MAX_QPATH) {
+		Com_Printf("Program name exceeds MAX_QPATH\n");
+		return 0;
+	}
+
+	/* search the currently loaded programs */
+	for (hProgram = 0; hProgram < tr.numPrograms; hProgram++) {
+		program = tr.programs[hProgram];
+		if (!strcmp(program->name, name)) {
+			if (!program->valid)
+				return 0;
+
+			return hProgram;
+		}
+	}
+
+	/* allocate a new glslProgram_t */
+	if ((program = R_GLSL_AllocProgram()) == NULL) {
+		ri.Printf(PRINT_WARNING, "RE_GLSL_RegisterProgram: R_GLSL_AllocProgram() failed for '%s'\n", name);
+		return 0;
+	}
+
+	/* only set the name after the program has successfully loaded */
+	Q_strncpyz(program->name, name, sizeof(program->name));
+
+	R_IssuePendingRenderCommands();
+
+	/* load the files */
+	if (!R_GLSL_LoadProgramRaw(program, name, (const char*)programVertexObjects, numVertexObjects, (const char*)programFragmentObjects, numFragmentObjects)) {
+		qglDeleteObjectARB(program->program);
+		program->valid = qfalse; 
+		//vertexShaders=0;     //If program in error disable the glsl feature altogether
+		return 0;
+	}
+
+	program->valid = qtrue;
+	return program->index;
+#endif
+}
+
+
+
 void R_RemapShader(const char *shaderName, const char *newShaderName, const char *timeOffset) {
 	char		strippedName[MAX_QPATH];
 	int			hash;
diff --git a/code/renderer_oa/tr_sky.c b/code/renderer_oa/tr_sky.c
