Пример #1
0
/*
 * R_UseMaterial
 */
static inline void R_UseMaterial(r_material_t *material) {
	static float last_b, last_p, last_s, last_h;
	float b, p, s, h;

	if (r_state.active_material == material)
		return;

	r_state.active_material = material;

	if (!r_state.active_material)
		return;

	b = r_state.active_material->bump * r_bumpmap->value;
	if (b != last_b)
		R_ProgramParameter1f("BUMP", b);
	last_b = b;

	p = r_state.active_material->parallax * r_parallax->value;
	if (p != last_p)
		R_ProgramParameter1f("PARALLAX", p);
	last_p = p;

	h = r_state.active_material->hardness * r_hardness->value;
	if (h != last_h)
		R_ProgramParameter1f("HARDNESS", h);
	last_h = h;

	s = r_state.active_material->specular * r_specular->value;
	if (s != last_s)
		R_ProgramParameter1f("SPECULAR", s);
	last_s = s;
}
Пример #2
0
/**
 * @brief
 */
void R_UseMaterial_default(const r_material_t *material) {

	r_default_program_t *p = &r_default_program;

	if (!material || !material->normalmap ||
	        !r_bumpmap->value || r_draw_bsp_lightmaps->value) {

		R_DisableAttribute(R_ARRAY_TANGENT);
		R_ProgramParameter1i(&p->normalmap, 0);
		return;
	}

	R_EnableAttribute(R_ARRAY_TANGENT);

	R_BindNormalmapTexture(material->normalmap->texnum);
	R_ProgramParameter1i(&p->normalmap, 1);

	if (material->specularmap) {
		R_BindSpecularmapTexture(material->specularmap->texnum);
		R_ProgramParameter1i(&p->glossmap, 1);
	} else {
		R_ProgramParameter1i(&p->glossmap, 0);
	}

	R_ProgramParameter1f(&p->bump, material->cm->bump * r_bumpmap->value);
	R_ProgramParameter1f(&p->parallax, material->cm->parallax * r_parallax->value);
	R_ProgramParameter1f(&p->hardness, material->cm->hardness * r_hardness->value);
	R_ProgramParameter1f(&p->specular, material->cm->specular * r_specular->value);
}
Пример #3
0
/*
 * R_EnableColorShell
 */
void R_EnableShell(boolean_t enable) {

	if (enable == r_state.shell_enabled)
		return;

	r_state.shell_enabled = enable;

	if (enable) {
		glEnable(GL_POLYGON_OFFSET_FILL);
		glPolygonOffset(-1.0, 0.0);

		R_EnableBlend(true);
		R_BlendFunc(GL_SRC_ALPHA, GL_ONE);

		if (r_state.lighting_enabled)
			R_ProgramParameter1f("OFFSET", r_view.time / 3.0);
	} else {
		R_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		R_EnableBlend(false);

		glPolygonOffset(0.0, 0.0);
		glDisable(GL_POLYGON_OFFSET_FILL);

		if (r_state.lighting_enabled)
			R_ProgramParameter1f("OFFSET", 0.0);
	}
}
Пример #4
0
/**
 * @brief
 */
void R_InitProgram_null(r_program_t *program) {

	r_null_program_t *p = &r_null_program;

	R_ProgramVariable(&program->attributes[R_ARRAY_POSITION], R_ATTRIBUTE, "POSITION", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_COLOR], R_ATTRIBUTE, "COLOR", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_DIFFUSE], R_ATTRIBUTE, "TEXCOORD", true);

	R_ProgramVariable(&program->attributes[R_ARRAY_NEXT_POSITION], R_ATTRIBUTE, "NEXT_POSITION", true);

	R_ProgramVariable(&p->sampler0, R_SAMPLER_2D, "SAMPLER0", true);

	R_ProgramVariable(&p->fog.start, R_UNIFORM_FLOAT, "FOG.START", true);
	R_ProgramVariable(&p->fog.end, R_UNIFORM_FLOAT, "FOG.END", true);
	R_ProgramVariable(&p->fog.color, R_UNIFORM_VEC3, "FOG.COLOR", true);
	R_ProgramVariable(&p->fog.density, R_UNIFORM_FLOAT, "FOG.DENSITY", true);

	R_ProgramVariable(&p->current_color, R_UNIFORM_VEC4, "GLOBAL_COLOR", true);

	R_ProgramVariable(&p->time_fraction, R_UNIFORM_FLOAT, "TIME_FRACTION", true);

	R_ProgramParameter1i(&p->sampler0, R_TEXUNIT_DIFFUSE);

	R_ProgramParameter1f(&p->fog.density, 0.0);

	const vec4_t white = { 1.0, 1.0, 1.0, 1.0 };
	R_ProgramParameter4fv(&p->current_color, white);

	R_ProgramParameter1f(&p->time_fraction, 0.0f);
}
Пример #5
0
/**
 * @brief
 */
void R_UseFog_default(const r_fog_parameters_t *fog) {

	r_default_program_t *p = &r_default_program;

	if (fog && fog->density) {
		R_ProgramParameter1f(&p->fog.density, fog->density);
		R_ProgramParameter1f(&p->fog.start, fog->start);
		R_ProgramParameter1f(&p->fog.end, fog->end);
		R_ProgramParameter3fv(&p->fog.color, fog->color);
	} else {
		R_ProgramParameter1f(&p->fog.density, 0.0);
	}
}
Пример #6
0
static void R_UseWarpProgram (r_program_t* prog)
{
	static vec4_t offset;

	offset[0] = offset[1] = refdef.time / 8.0;
	R_ProgramParameter4fv("OFFSET", offset);
	if (r_fog->integer) {
		if (r_state.fog_enabled) {
			R_ProgramParameter3fv("FOGCOLOR", refdef.fogColor);
			R_ProgramParameter1f("FOGDENSITY", refdef.fogColor[3]);
			R_ProgramParameter2fv("FOGRANGE", fogRange);
		} else {
			R_ProgramParameter1f("FOGDENSITY", 0.0f);
		}
	}
}
Пример #7
0
/**
 * @brief
 */
void R_UseLight_default(const uint16_t light_index, const r_light_t *light) {

	r_default_program_t *p = &r_default_program;

	if (light && light->radius) {
		vec3_t origin;
		const matrix4x4_t *modelview = R_GetMatrixPtr(R_MATRIX_MODELVIEW);
		Matrix4x4_Transform(modelview, light->origin, origin);

		R_ProgramParameter3fv(&p->lights[light_index].origin, origin);
		R_ProgramParameter3fv(&p->lights[light_index].color, light->color);
		R_ProgramParameter1f(&p->lights[light_index].radius, light->radius);
	} else {
		R_ProgramParameter1f(&p->lights[light_index].radius, 0.0);
	}
}
Пример #8
0
static void R_UseWorldProgram (r_program_t* prog)
{
	if (r_programs->integer > 1) {
		R_ProgramParameter3fv("AMBIENT", refdef.ambientColor);
	}

	if (r_fog->integer) {
		if (r_state.fog_enabled) {
			R_ProgramParameter3fv("FOGCOLOR", refdef.fogColor);
			R_ProgramParameter1f("FOGDENSITY", refdef.fogColor[3]);
			R_ProgramParameter2fv("FOGRANGE", fogRange);
		} else {
			R_ProgramParameter1f("FOGDENSITY", 0.0f);
		}
	}
}
Пример #9
0
static void R_InitWorldProgram (r_program_t* prog)
{
	R_ProgramParameter1i("SAMPLER_DIFFUSE", 0);
	R_ProgramParameter1i("SAMPLER_LIGHTMAP", 1);
	R_ProgramParameter1i("SAMPLER_DELUXEMAP", 2);
	R_ProgramParameter1i("SAMPLER_NORMALMAP", 3);
	R_ProgramParameter1i("SAMPLER_GLOWMAP", 4);

	R_ProgramParameter1i("BUMPMAP", 0);

	if (r_programs->integer > 1) {
		R_ProgramParameter3fv("AMBIENT", refdef.ambientColor);

		R_ProgramParameter1i("SPECULARMAP", 0);
		R_ProgramParameter1i("SAMPLER_SPECULAR", 5);

		R_ProgramParameter1f("HARDNESS", defaultMaterial.hardness);
		R_ProgramParameter1f("SPECULAR", defaultMaterial.specular);
		R_ProgramParameter1f("PARALLAX", defaultMaterial.parallax);
	}

	R_ProgramParameter1f("BUMP", defaultMaterial.bump);
	R_ProgramParameter1f("GLOWSCALE", defaultMaterial.glowscale);

	if (r_fog->integer) {
		if (r_state.fog_enabled) {
			R_ProgramParameter3fv("FOGCOLOR", refdef.fogColor);
			R_ProgramParameter1f("FOGDENSITY", refdef.fogColor[3]);
			R_ProgramParameter2fv("FOGRANGE", fogRange);
		} else {
			R_ProgramParameter1f("FOGDENSITY", 0.0f);
		}
	}
}
Пример #10
0
static void R_InitWarpProgram (r_program_t* prog)
{
	static vec4_t offset;

	R_ProgramParameter1i("SAMPLER_DIFFUSE", 0);
	R_ProgramParameter1i("SAMPLER_WARP", 1);
	R_ProgramParameter1i("SAMPLER_GLOWMAP", 4);
	R_ProgramParameter1f("GLOWSCALE", 0.0);
	R_ProgramParameter4fv("OFFSET", offset);
	if (r_fog->integer) {
		if (r_state.fog_enabled) {
			R_ProgramParameter3fv("FOGCOLOR", refdef.fogColor);
			R_ProgramParameter1f("FOGDENSITY", refdef.fogColor[3]);
			R_ProgramParameter2fv("FOGRANGE", fogRange);
		} else {
			R_ProgramParameter1f("FOGDENSITY", 0.0f);
		}
	}
}
Пример #11
0
static void R_UseModelProgram (r_program_t* prog)
{
	vec4_t sunDirection;
	/*R_ProgramParameter1i("LIGHTS", refdef.numLights);*/

	R_ProgramParameter1f("OFFSET", 0.0);
	R_ProgramParameter3fv("AMBIENT", refdef.modelAmbientColor);
	R_ProgramParameter3fv("SUNCOLOR", refdef.sunDiffuseColor);

	GLVectorTransform(r_locals.world_matrix, refdef.sunVector, sunDirection);
	R_ProgramParameter3fv("SUNDIRECTION", sunDirection); /* last component is not needed */

	if (r_fog->integer) {
		if (r_state.fog_enabled) {
			R_ProgramParameter3fv("FOGCOLOR", refdef.fogColor);
			R_ProgramParameter1f("FOGDENSITY", refdef.fogColor[3]);
			R_ProgramParameter2fv("FOGRANGE", fogRange);
		} else {
			R_ProgramParameter1f("FOGDENSITY", 0.0f);
		}
	}
}
Пример #12
0
/**
 * @brief
 */
void R_InitProgram_shell(r_program_t *program) {
	r_shell_program_t *p = &r_shell_program;

	R_ProgramVariable(&program->attributes[R_ATTRIB_POSITION], R_ATTRIBUTE, "POSITION", true);
	R_ProgramVariable(&program->attributes[R_ATTRIB_NORMAL], R_ATTRIBUTE, "NORMAL", true);
	R_ProgramVariable(&program->attributes[R_ATTRIB_DIFFUSE], R_ATTRIBUTE, "TEXCOORD", true);

	R_ProgramVariable(&program->attributes[R_ATTRIB_NEXT_POSITION], R_ATTRIBUTE, "NEXT_POSITION", true);
	R_ProgramVariable(&program->attributes[R_ATTRIB_NEXT_NORMAL], R_ATTRIBUTE, "NEXT_NORMAL", true);

	R_ProgramVariable(&p->offset, R_UNIFORM_FLOAT, "OFFSET", true);
	R_ProgramParameter1f(&p->offset, 0.0);

	R_ProgramVariable(&p->shell_offset, R_UNIFORM_FLOAT, "SHELL_OFFSET", true);
	R_ProgramParameter1f(&p->shell_offset, 0.0);

	R_ProgramVariable(&p->sampler0, R_SAMPLER_2D, "SAMPLER0", true);
	R_ProgramParameter1i(&p->sampler0, R_TEXUNIT_DIFFUSE);

	R_ProgramVariable(&p->time_fraction, R_UNIFORM_FLOAT, "TIME_FRACTION", true);

	R_ProgramParameter1f(&p->time_fraction, 0.0f);
}
Пример #13
0
/**
 * @brief
 */
void R_UseCaustic_default(const r_caustic_parameters_t *caustic) {

	r_default_program_t *p = &r_default_program;

	if (caustic && caustic->enable) {
		R_ProgramParameter1i(&p->caustic.enable, caustic->enable);

		R_ProgramParameter3fv(&p->caustic.color, caustic->color);

		R_ProgramParameter1f(&p->time, r_view.ticks / 1000.0);
	} else {
		R_ProgramParameter1i(&p->caustic.enable, 0);
	}
}
Пример #14
0
/**
 * @brief
 */
void R_InitProgram_null(r_program_t *program) {

	r_null_program_t *p = &r_null_program;

	R_ProgramVariable(&program->attributes[R_ATTRIB_POSITION], R_ATTRIBUTE, "POSITION", true);
	R_ProgramVariable(&program->attributes[R_ATTRIB_COLOR], R_ATTRIBUTE, "COLOR", true);
	R_ProgramVariable(&program->attributes[R_ATTRIB_DIFFUSE], R_ATTRIBUTE, "TEXCOORD", true);

	R_ProgramVariable(&program->attributes[R_ATTRIB_NEXT_POSITION], R_ATTRIBUTE, "NEXT_POSITION", true);
	
	R_ProgramVariable(&p->tintmap, R_UNIFORM_INT, "TINTMAP", true);

	R_ProgramVariable(&p->sampler0, R_SAMPLER_2D, "SAMPLER0", true);
	R_ProgramVariable(&p->sampler6, R_SAMPLER_2D, "SAMPLER6", true);

	R_ProgramVariable(&p->fog.start, R_UNIFORM_FLOAT, "FOG.START", true);
	R_ProgramVariable(&p->fog.end, R_UNIFORM_FLOAT, "FOG.END", true);
	R_ProgramVariable(&p->fog.color, R_UNIFORM_VEC3, "FOG.COLOR", true);
	R_ProgramVariable(&p->fog.density, R_UNIFORM_FLOAT, "FOG.DENSITY", true);
	
	for (int32_t i = 0; i < TINT_TOTAL; i++) {
		R_ProgramVariable(&p->tints[i], R_UNIFORM_VEC4, va("TINTS[%i]", i), true);
	}

	R_ProgramVariable(&p->time_fraction, R_UNIFORM_FLOAT, "TIME_FRACTION", true);

	R_ProgramParameter1i(&p->tintmap, 0);

	R_ProgramParameter1i(&p->sampler0, R_TEXUNIT_DIFFUSE);
	R_ProgramParameter1i(&p->sampler6, R_TEXUNIT_TINTMAP);

	R_ProgramParameter1f(&p->fog.density, 0.0);

	R_ProgramParameter1f(&p->time_fraction, 0.0f);

}
Пример #15
0
static void R_StageGlow (const materialStage_t *stage)
{
	image_t *glowmap;

	if (stage->flags & STAGE_GLOWMAPLINK)
		glowmap = stage->image;
	else
		glowmap = stage->image->glowmap;

	if (glowmap) {
		R_EnableGlowMap(glowmap);
		if (r_state.glowmap_enabled)
			R_ProgramParameter1f("GLOWSCALE", stage->glowscale);
	} else {
		R_EnableGlowMap(nullptr);
	}
}
Пример #16
0
static void R_InitModelProgram (r_program_t* prog)
{
	vec4_t sunDirection;

	R_ProgramParameter1i("SAMPLER_DIFFUSE", 0);
	R_ProgramParameter1i("SAMPLER_NORMALMAP", 3);
	R_ProgramParameter1i("SAMPLER_GLOWMAP", 4);

	R_ProgramParameter1i("BUMPMAP", 0);
	R_ProgramParameter1i("ANIMATE", 0);

	R_ProgramParameter1f("BUMP", defaultMaterial.bump);
	R_ProgramParameter1f("GLOWSCALE", defaultMaterial.glowscale);
	R_ProgramParameter1f("OFFSET", 0.0);

	R_ProgramParameter3fv("AMBIENT", refdef.modelAmbientColor);
	R_ProgramParameter3fv("SUNCOLOR", refdef.sunDiffuseColor);

	GLVectorTransform(r_locals.world_matrix, refdef.sunVector, sunDirection);
	R_ProgramParameter3fv("SUNDIRECTION", sunDirection); /* last component is not needed */

	if (r_programs->integer > 1) {
		R_ProgramParameter1i("SAMPLER_SPECULAR", 5);
		R_ProgramParameter1i("SPECULARMAP", 0);
		R_ProgramParameter1f("HARDNESS", defaultMaterial.hardness);
		R_ProgramParameter1f("SPECULAR", defaultMaterial.specular);
		R_ProgramParameter1f("PARALLAX", defaultMaterial.parallax);
		if (r_programs->integer > 2) {
			R_ProgramParameter1i("SAMPLER_ROUGHMAP", 2);
			R_ProgramParameter1i("ROUGHMAP", 0);
		}
	}

	if (r_fog->integer) {
		if (r_state.fog_enabled) {
			R_ProgramParameter3fv("FOGCOLOR", refdef.fogColor);
			R_ProgramParameter1f("FOGDENSITY", refdef.fogColor[3]);
			R_ProgramParameter2fv("FOGRANGE", fogRange);
		} else {
			R_ProgramParameter1f("FOGDENSITY", 0.0f);
		}
	}
}
Пример #17
0
static void R_InitSimpleGlowProgram (r_program_t* prog)
{
	R_ProgramParameter1i("SAMPLER_DIFFUSE", 0);
	R_ProgramParameter1i("SAMPLER_GLOWMAP", 4);
	R_ProgramParameter1f("GLOWSCALE", 1.0);
}
Пример #18
0
/**
 * @brief
 */
void R_UseInterpolation_shell(const vec_t time_fraction) {

	r_shell_program_t *p = &r_shell_program;

	R_ProgramParameter1f(&p->time_fraction, time_fraction);
}
Пример #19
0
/**
 * @brief
 */
void R_UseProgram_shell(void) {

	R_ProgramParameter1f(&r_shell_program.offset, r_view.ticks * 0.00025);
}
Пример #20
0
/**
 * @brief
 */
void R_UseInterpolation_default(const vec_t time_fraction) {

	r_default_program_t *p = &r_default_program;

	R_ProgramParameter1f(&p->time_fraction, time_fraction);
}
Пример #21
0
/**
 * @brief
 */
void R_UseAlphaTest_default(const vec_t threshold) {

	r_default_program_t *p = &r_default_program;

	R_ProgramParameter1f(&p->alpha_threshold, threshold);
}
Пример #22
0
/**
 * @brief
 */
void R_InitProgram_default(r_program_t *program) {

	r_default_program_t *p = &r_default_program;

	p->program = program;

	R_ProgramVariable(&program->attributes[R_ARRAY_POSITION], R_ATTRIBUTE, "POSITION", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_COLOR], R_ATTRIBUTE, "COLOR", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_DIFFUSE], R_ATTRIBUTE, "TEXCOORD0", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_LIGHTMAP], R_ATTRIBUTE, "TEXCOORD1", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_NORMAL], R_ATTRIBUTE, "NORMAL", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_TANGENT], R_ATTRIBUTE, "TANGENT", true);

	R_ProgramVariable(&program->attributes[R_ARRAY_NEXT_POSITION], R_ATTRIBUTE, "NEXT_POSITION", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_NEXT_NORMAL], R_ATTRIBUTE, "NEXT_NORMAL", true);
	R_ProgramVariable(&program->attributes[R_ARRAY_NEXT_TANGENT], R_ATTRIBUTE, "NEXT_TANGENT", true);

	R_ProgramVariable(&p->diffuse, R_UNIFORM_INT, "DIFFUSE", true);
	R_ProgramVariable(&p->lightmap, R_UNIFORM_INT, "LIGHTMAP", true);
	R_ProgramVariable(&p->normalmap, R_UNIFORM_INT, "NORMALMAP", true);
	R_ProgramVariable(&p->glossmap, R_UNIFORM_INT, "GLOSSMAP", true);

	R_ProgramVariable(&p->bump, R_UNIFORM_FLOAT, "BUMP", true);
	R_ProgramVariable(&p->parallax, R_UNIFORM_FLOAT, "PARALLAX", true);
	R_ProgramVariable(&p->hardness, R_UNIFORM_FLOAT, "HARDNESS", true);
	R_ProgramVariable(&p->specular, R_UNIFORM_FLOAT, "SPECULAR", true);

	R_ProgramVariable(&p->sampler0, R_SAMPLER_2D, "SAMPLER0", true);
	R_ProgramVariable(&p->sampler1, R_SAMPLER_2D, "SAMPLER1", true);
	R_ProgramVariable(&p->sampler2, R_SAMPLER_2D, "SAMPLER2", true);
	R_ProgramVariable(&p->sampler3, R_SAMPLER_2D, "SAMPLER3", true);
	R_ProgramVariable(&p->sampler4, R_SAMPLER_2D, "SAMPLER4", true);

	R_ProgramVariable(&p->fog.start, R_UNIFORM_FLOAT, "FOG.START", true);
	R_ProgramVariable(&p->fog.end, R_UNIFORM_FLOAT, "FOG.END", true);
	R_ProgramVariable(&p->fog.color, R_UNIFORM_VEC3, "FOG.COLOR", true);
	R_ProgramVariable(&p->fog.density, R_UNIFORM_FLOAT, "FOG.DENSITY", true);

	if (r_state.max_active_lights) {
		p->lights = Mem_TagMalloc(sizeof(r_uniform_light_t) * r_state.max_active_lights, MEM_TAG_RENDERER);

		for (int32_t i = 0; i < r_state.max_active_lights; ++i) {
			R_ProgramVariable(&p->lights[i].origin, R_UNIFORM_VEC3, va("LIGHTS.ORIGIN[%i]", i), true);
			R_ProgramVariable(&p->lights[i].color, R_UNIFORM_VEC3, va("LIGHTS.COLOR[%i]", i), true);
			R_ProgramVariable(&p->lights[i].radius, R_UNIFORM_FLOAT, va("LIGHTS.RADIUS[%i]", i), true);
		}

		R_ProgramParameter1f(&p->lights[0].radius, 0.0);
	} else {
		p->lights = NULL;
	}

	R_ProgramVariable(&p->caustic.enable, R_UNIFORM_INT, "CAUSTIC.ENABLE", true);
	R_ProgramVariable(&p->caustic.color, R_UNIFORM_VEC3, "CAUSTIC.COLOR", true);

	R_ProgramVariable(&p->normal_mat, R_UNIFORM_MAT4, "NORMAL_MAT", true);

	R_ProgramVariable(&p->alpha_threshold, R_UNIFORM_FLOAT, "ALPHA_THRESHOLD", true);

	R_ProgramVariable(&p->time_fraction, R_UNIFORM_FLOAT, "TIME_FRACTION", true);
	R_ProgramVariable(&p->time, R_UNIFORM_FLOAT, "TIME", true);

	R_ProgramParameter1i(&p->lightmap, 0);
	R_ProgramParameter1i(&p->normalmap, 0);
	R_ProgramParameter1i(&p->glossmap, 0);

	R_ProgramParameter1f(&p->bump, 1.0);
	R_ProgramParameter1f(&p->parallax, 1.0);
	R_ProgramParameter1f(&p->hardness, 1.0);
	R_ProgramParameter1f(&p->specular, 1.0);

	R_ProgramParameter1i(&p->sampler0, R_TEXUNIT_DIFFUSE);
	R_ProgramParameter1i(&p->sampler1, R_TEXUNIT_LIGHTMAP);
	R_ProgramParameter1i(&p->sampler2, R_TEXUNIT_DELUXEMAP);
	R_ProgramParameter1i(&p->sampler3, R_TEXUNIT_NORMALMAP);
	R_ProgramParameter1i(&p->sampler4, R_TEXUNIT_SPECULARMAP);

	R_ProgramParameter1f(&p->fog.density, 0.0);
	R_ProgramParameter1f(&p->alpha_threshold, ALPHA_TEST_DISABLED_THRESHOLD);

	R_ProgramParameter1i(&p->caustic.enable, 0);

	R_ProgramParameter1f(&p->time_fraction, 0.0f);
	R_ProgramParameter1f(&p->time, 0.0f);
}
Пример #23
0
/**
 * @brief
 */
void R_UseShellOffset_shell(const vec_t offset) {

	R_ProgramParameter1f(&r_shell_program.shell_offset, offset);
}