* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * TUNGSTEN GRAPHICS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * TUNGSTEN GRAPHICS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
{
dst->File = reg.file;
dst->Index = reg.idx;
- dst->WriteMask = mask ? mask : WRITEMASK_XYZW; /* allow zero as a shorthand for xyzw */
+ /* allow zero as a shorthand for xyzw */
+ dst->WriteMask = mask ? mask : WRITEMASK_XYZW;
dst->pad = 0;
}
-static void debug_insn( struct vp_instruction *inst, const char *fn, GLuint line )
+static void debug_insn( struct vp_instruction *inst, const char *fn,
+ GLuint line )
{
#if DISASSEM
static const char *last_fn;
-#define emit_op3(p, op, dst, mask, src0, src1, src2) emit_op3fn(p, op, dst, mask, src0, src1, src2, __FUNCTION__, __LINE__)
-#define emit_op2(p, op, dst, mask, src0, src1) emit_op3fn(p, op, dst, mask, src0, src1, undef, __FUNCTION__, __LINE__)
-#define emit_op1(p, op, dst, mask, src0) emit_op3fn(p, op, dst, mask, src0, undef, undef, __FUNCTION__, __LINE__)
+#define emit_op3(p, op, dst, mask, src0, src1, src2) \
+ emit_op3fn(p, op, dst, mask, src0, src1, src2, __FUNCTION__, __LINE__)
+
+#define emit_op2(p, op, dst, mask, src0, src1) \
+ emit_op3fn(p, op, dst, mask, src0, src1, undef, __FUNCTION__, __LINE__)
+
+#define emit_op1(p, op, dst, mask, src0) \
+ emit_op3fn(p, op, dst, mask, src0, undef, undef, __FUNCTION__, __LINE__)
static struct ureg make_temp( struct tnl_program *p, struct ureg reg )
emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_Y, src, mat[1]);
emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_Z, src, mat[2]);
emit_op2(p, VP_OPCODE_DP4, dest, WRITEMASK_W, src, mat[3]);
+}
+
+static void emit_transpose_matrix_transform_vec4( struct tnl_program *p,
+ struct ureg dest,
+ const struct ureg *mat,
+ struct ureg src)
+{
+ struct ureg tmp;
+
+ if (dest.file != PROGRAM_TEMPORARY)
+ tmp = get_temp(p);
+ else
+ tmp = dest;
+ emit_op2(p, VP_OPCODE_MUL, tmp, 0, swizzle1(src,X), mat[0]);
+ emit_op3(p, VP_OPCODE_MAD, tmp, 0, swizzle1(src,Y), mat[1], tmp);
+ emit_op3(p, VP_OPCODE_MAD, tmp, 0, swizzle1(src,Z), mat[2], tmp);
+ emit_op3(p, VP_OPCODE_MAD, dest, 0, swizzle1(src,W), mat[3], tmp);
+
+ if (dest.file != PROGRAM_TEMPORARY)
+ release_temp(p, tmp);
}
static void emit_matrix_transform_vec3( struct tnl_program *p,
struct ureg pos = register_input( p, VERT_ATTRIB_POS );
struct ureg modelview[4];
- register_matrix_param6( p, STATE_MATRIX, STATE_MODELVIEW, 0, 0, 3, 0, modelview );
+ register_matrix_param6( p, STATE_MATRIX, STATE_MODELVIEW, 0, 0, 3,
+ STATE_MATRIX_TRANSPOSE, modelview );
p->eye_position = reserve_temp(p);
- emit_matrix_transform_vec4( p, p->eye_position, modelview, pos );
+ emit_transpose_matrix_transform_vec4(p, p->eye_position, modelview, pos);
}
return p->eye_position;
struct ureg normal = register_input(p, VERT_ATTRIB_NORMAL );
struct ureg mvinv[3];
- register_matrix_param6( p, STATE_MATRIX, STATE_MODELVIEW, 0, 0, 2, STATE_MATRIX_INVTRANS, mvinv );
+ register_matrix_param6( p, STATE_MATRIX, STATE_MODELVIEW, 0, 0, 2,
+ STATE_MATRIX_INVTRANS, mvinv );
p->eye_normal = reserve_temp(p);
emit_normalize_vec3( p, p->eye_normal, p->eye_normal );
}
else if (p->ctx->Transform.RescaleNormals) {
- struct ureg rescale = register_param2(p, STATE_INTERNAL, STATE_NORMAL_SCALE);
- emit_op2( p, VP_OPCODE_MUL, p->eye_normal, 0, normal, swizzle1(rescale, X));
+ struct ureg rescale = register_param2(p, STATE_INTERNAL,
+ STATE_NORMAL_SCALE);
+
+ emit_op2( p, VP_OPCODE_MUL, p->eye_normal, 0, normal,
+ swizzle1(rescale, X));
}
}
struct ureg hpos = register_output( p, VERT_RESULT_HPOS );
struct ureg mvp[4];
- register_matrix_param6( p, STATE_MATRIX, STATE_MVP, 0, 0, 3, 0, mvp );
- emit_matrix_transform_vec4( p, hpos, mvp, pos );
+ register_matrix_param6( p, STATE_MATRIX, STATE_MVP, 0, 0, 3,
+ STATE_MATRIX_TRANSPOSE, mvp );
+ emit_transpose_matrix_transform_vec4( p, hpos, mvp, pos );
}
static GLuint material_attrib( GLuint side, GLuint property )
{
- return _TNL_ATTRIB_MAT_FRONT_AMBIENT + (property - STATE_AMBIENT) * 2 + side;
+ return (_TNL_ATTRIB_MAT_FRONT_AMBIENT +
+ (property - STATE_AMBIENT) * 2 +
+ side);
}
static void set_material_flags( struct tnl_program *p )
}
-static struct ureg get_material( struct tnl_program *p, GLuint side, GLuint property )
+static struct ureg get_material( struct tnl_program *p, GLuint side,
+ GLuint property )
{
GLuint attrib = material_attrib(side, property);
static struct ureg get_scenecolor( struct tnl_program *p, GLuint side )
{
if (p->materials & SCENE_COLOR_BITS(side)) {
- struct ureg lightmodel_ambient = register_param1(p, STATE_LIGHTMODEL_AMBIENT);
+ struct ureg lm_ambient = register_param1(p, STATE_LIGHTMODEL_AMBIENT);
struct ureg material_emission = get_material(p, side, STATE_EMISSION);
struct ureg material_ambient = get_material(p, side, STATE_AMBIENT);
struct ureg material_diffuse = get_material(p, side, STATE_DIFFUSE);
struct ureg tmp = make_temp(p, material_diffuse);
- emit_op3(p, VP_OPCODE_MAD, tmp, WRITEMASK_XYZ, lightmodel_ambient, material_ambient, material_emission);
+ emit_op3(p, VP_OPCODE_MAD, tmp, WRITEMASK_XYZ, lm_ambient,
+ material_ambient, material_emission);
return tmp;
}
else
}
-static struct ureg get_lightprod( struct tnl_program *p, GLuint light, GLuint side, GLuint property )
+static struct ureg get_lightprod( struct tnl_program *p, GLuint light,
+ GLuint side, GLuint property )
{
GLuint attrib = material_attrib(side, property);
if (p->materials & (1<<attrib)) {
- struct ureg light_value = register_param3(p, STATE_LIGHT, light, property);
+ struct ureg light_value =
+ register_param3(p, STATE_LIGHT, light, property);
struct ureg material_value = get_material(p, side, property);
struct ureg tmp = get_temp(p);
emit_op2(p, VP_OPCODE_MUL, tmp, 0, light_value, material_value);
return register_param4(p, STATE_LIGHTPROD, light, side, property);
}
+static struct ureg calculate_light_attenuation( struct tnl_program *p,
+ GLuint i,
+ struct gl_light *light,
+ struct ureg VPpli,
+ struct ureg dist )
+{
+ struct ureg attenuation = register_param3(p, STATE_LIGHT, i,
+ STATE_ATTENUATION);
+ struct ureg att = get_temp(p);
+
+ /* Calculate spot attenuation:
+ */
+ if (light->SpotCutoff != 180.0F) {
+ struct ureg spot_dir = register_param3(p, STATE_LIGHT, i,
+ STATE_SPOT_DIRECTION);
+ struct ureg spot = get_temp(p);
+ struct ureg slt = get_temp(p);
+
+ emit_normalize_vec3( p, spot, spot_dir ); /* XXX: precompute! */
+ emit_op2(p, VP_OPCODE_DP3, spot, 0, negate(VPpli), spot_dir);
+ emit_op2(p, VP_OPCODE_SLT, slt, 0, swizzle1(spot_dir,W), spot);
+ emit_op2(p, VP_OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W));
+ emit_op2(p, VP_OPCODE_MUL, att, 0, slt, spot);
+
+ release_temp(p, spot);
+ release_temp(p, slt);
+ }
+
+ /* Calculate distance attenuation:
+ */
+ if (light->ConstantAttenuation != 1.0 ||
+ light->LinearAttenuation != 1.0 ||
+ light->QuadraticAttenuation != 1.0) {
+
+ /* 1/d,d,d,1/d */
+ emit_op1(p, VP_OPCODE_RCP, dist, WRITEMASK_YZ, dist);
+ /* 1,d,d*d,1/d */
+ emit_op2(p, VP_OPCODE_MUL, dist, WRITEMASK_XZ, dist, swizzle1(dist,Y));
+ /* 1/dist-atten */
+ emit_op2(p, VP_OPCODE_DP3, dist, 0, attenuation, dist);
+
+ if (light->SpotCutoff != 180.0F) {
+ /* dist-atten */
+ emit_op1(p, VP_OPCODE_RCP, dist, 0, dist);
+ /* spot-atten * dist-atten */
+ emit_op2(p, VP_OPCODE_MUL, att, 0, dist, att);
+ } else {
+ /* dist-atten */
+ emit_op1(p, VP_OPCODE_RCP, att, 0, dist);
+ }
+ }
+
+ return att;
+}
+
+
if (twoside) {
struct ureg shininess = get_material(p, 1, STATE_SHININESS);
- emit_op1(p, VP_OPCODE_MOV, dots, WRITEMASK_Z, negate(swizzle1(shininess,X)));
+ emit_op1(p, VP_OPCODE_MOV, dots, WRITEMASK_Z,
+ negate(swizzle1(shininess,X)));
release_temp(p, shininess);
_bfc0 = make_temp(p, get_scenecolor(p, 1));
if (light->EyePosition[3] == 0) {
/* Can used precomputed constants in this case:
*/
- VPpli = register_param3(p, STATE_LIGHT, i, STATE_POSITION_NORMALIZED);
+ VPpli = register_param3(p, STATE_LIGHT, i,
+ STATE_POSITION_NORMALIZED);
half = register_param3(p, STATE_LIGHT, i, STATE_HALF);
- /* Spot attenuation maybe applies to this case? Could precompute if so? */
+ /* Spot attenuation maybe applies to this case? Could
+ * precompute if so? */
}
else {
- struct ureg Ppli = register_param3(p, STATE_LIGHT, i, STATE_POSITION);
+ struct ureg Ppli = register_param3(p, STATE_LIGHT, i,
+ STATE_POSITION);
struct ureg V = get_eye_position(p);
- struct ureg dst = get_temp(p);
+ struct ureg dist = get_temp(p);
VPpli = get_temp(p);
half = get_temp(p);
*/
emit_op2(p, VP_OPCODE_SUB, VPpli, 0, Ppli, V);
- /* Normalize VPpli. The dst value also used in
+ /* Normalize VPpli. The dist value also used in
* attenuation below.
*/
- emit_op2(p, VP_OPCODE_DP3, dst, 0, VPpli, VPpli);
- emit_op1(p, VP_OPCODE_RSQ, dst, 0, dst);
- emit_op2(p, VP_OPCODE_MUL, VPpli, 0, VPpli, dst);
+ emit_op2(p, VP_OPCODE_DP3, dist, 0, VPpli, VPpli);
+ emit_op1(p, VP_OPCODE_RSQ, dist, 0, dist);
+ emit_op2(p, VP_OPCODE_MUL, VPpli, 0, VPpli, dist);
/* Calculate attenuation:
light->ConstantAttenuation != 1.0 ||
light->LinearAttenuation != 1.0 ||
light->QuadraticAttenuation != 1.0) {
-
- struct ureg attenuation = register_param3(p, STATE_LIGHT, i, STATE_ATTENUATION);
- att = get_temp(p);
-
- /* Calculate spot attenuation:
- */
- if (light->SpotCutoff != 180.0F) {
- struct ureg spot_dir = register_param3(p, STATE_LIGHT, i, STATE_SPOT_DIRECTION);
- struct ureg spot = get_temp(p);
- struct ureg slt = get_temp(p);
-
- emit_normalize_vec3( p, spot, spot_dir ); /* XXX: precompute! */
- emit_op2(p, VP_OPCODE_DP3, spot, 0, negate(VPpli), spot_dir);
- emit_op2(p, VP_OPCODE_SLT, slt, 0, swizzle1(spot_dir,W), spot);
- emit_op2(p, VP_OPCODE_POW, spot, 0, spot, swizzle1(attenuation, W));
- emit_op2(p, VP_OPCODE_MUL, att, 0, slt, spot);
-
- release_temp(p, spot);
- release_temp(p, slt);
- }
-
- /* Calculate distance attenuation:
- */
- if (light->ConstantAttenuation != 1.0 ||
- light->LinearAttenuation != 1.0 ||
- light->QuadraticAttenuation != 1.0) {
-
- emit_op1(p, VP_OPCODE_RCP, dst, WRITEMASK_YZ, dst); /* 1/d,d,d,1/d */
- emit_op2(p, VP_OPCODE_MUL, dst, WRITEMASK_XZ, dst, swizzle1(dst,Y)); /* 1,d,d*d,1/d */
- emit_op2(p, VP_OPCODE_DP3, dst, 0, attenuation, dst); /* 1/dist-atten */
-
- if (light->SpotCutoff != 180.0F) {
- emit_op1(p, VP_OPCODE_RCP, dst, 0, dst); /* dist-atten */
- emit_op2(p, VP_OPCODE_MUL, att, 0, dst, att); /* spot-atten * dist-atten */
- } else {
- emit_op1(p, VP_OPCODE_RCP, att, 0, dst); /* dist-atten */
- }
- }
+ att = calculate_light_attenuation(p, i, light, VPpli, dist);
}
emit_op2(p, VP_OPCODE_SUB, half, 0, VPpli, eye_hat);
}
else {
- struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z); /* 0,0,1,0 */
+ struct ureg z_dir = swizzle(get_identity_param(p),X,Y,W,Z);
emit_op2(p, VP_OPCODE_ADD, half, 0, VPpli, z_dir);
}
emit_normalize_vec3(p, half, half);
- release_temp(p, dst);
+ release_temp(p, dist);
}
/* Calculate dot products:
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct ureg fog = register_output(p, VERT_RESULT_FOGC);
struct ureg input;
-
+
if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT) {
input = swizzle1(get_eye_position(p), Z);
}
emit_op2(p, VP_OPCODE_SUB, tmp, 0, swizzle1(params,Z), input);
emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, swizzle1(params,W));
emit_op2(p, VP_OPCODE_MAX, tmp, 0, tmp, swizzle1(id,X)); /* saturate */
- emit_op2(p, VP_OPCODE_MIN, fog, WRITEMASK_X, tmp, swizzle1(id,W)); /* saturate */
+ emit_op2(p, VP_OPCODE_MIN, fog, WRITEMASK_X, tmp, swizzle1(id,W));
break;
}
case GL_EXP:
emit_op1(p, VP_OPCODE_ABS, tmp, 0, input);
emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, swizzle1(params,X));
- emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X, register_const1f(p, M_E), negate(tmp));
+ emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X,
+ register_const1f(p, M_E), negate(tmp));
break;
case GL_EXP2:
emit_op2(p, VP_OPCODE_MUL, tmp, 0, input, swizzle1(params,X));
emit_op2(p, VP_OPCODE_MUL, tmp, 0, tmp, tmp);
- emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X, register_const1f(p, M_E), negate(tmp));
+ emit_op2(p, VP_OPCODE_POW, fog, WRITEMASK_X,
+ register_const1f(p, M_E), negate(tmp));
break;
}
emit_op1(p, VP_OPCODE_MOV, fog, WRITEMASK_X, input);
}
}
+
+static void build_reflect_texgen( struct tnl_program *p,
+ struct ureg dest,
+ GLuint writemask )
+{
+ struct ureg normal = get_eye_normal(p);
+ struct ureg eye_hat = get_eye_position_normalized(p);
+ struct ureg tmp = get_temp(p);
+ /* n.u */
+ emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat);
+ /* 2n.u */
+ emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp);
+ /* (-2n.u)n + u */
+ emit_op3(p, VP_OPCODE_MAD, dest, writemask, negate(tmp), normal, eye_hat);
+}
+
+static void build_sphere_texgen( struct tnl_program *p,
+ struct ureg dest,
+ GLuint writemask )
+{
+ struct ureg normal = get_eye_normal(p);
+ struct ureg eye_hat = get_eye_position_normalized(p);
+ struct ureg tmp = get_temp(p);
+ struct ureg half = register_const1f(p, .5);
+ struct ureg r = get_temp(p);
+ struct ureg inv_m = get_temp(p);
+ struct ureg id = get_identity_param(p);
+
+ /* Could share the above calculations, but it would be
+ * a fairly odd state for someone to set (both sphere and
+ * reflection active for different texture coordinate
+ * components. Of course - if two texture units enable
+ * reflect and/or sphere, things start to tilt in favour
+ * of seperating this out:
+ */
+
+ /* n.u */
+ emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat);
+ /* 2n.u */
+ emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp);
+ /* (-2n.u)n + u */
+ emit_op3(p, VP_OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat);
+ /* r + 0,0,1 */
+ emit_op2(p, VP_OPCODE_ADD, tmp, 0, r, swizzle(id,X,Y,W,Z));
+ /* rx^2 + ry^2 + (rz+1)^2 */
+ emit_op2(p, VP_OPCODE_DP3, tmp, 0, tmp, tmp);
+ /* 2/m */
+ emit_op1(p, VP_OPCODE_RSQ, tmp, 0, tmp);
+ /* 1/m */
+ emit_op2(p, VP_OPCODE_MUL, inv_m, 0, tmp, swizzle1(half,X));
+ /* r/m + 1/2 */
+ emit_op3(p, VP_OPCODE_MAD, dest, writemask, r, inv_m, swizzle1(half,X));
+
+ release_temp(p, tmp);
+ release_temp(p, r);
+ release_temp(p, inv_m);
+}
static void build_texture_transform( struct tnl_program *p )
switch (modes[j]) {
case GL_OBJECT_LINEAR: {
struct ureg obj = register_input(p, VERT_ATTRIB_POS);
- struct ureg plane = register_param3(p, STATE_TEXGEN, i, STATE_TEXGEN_OBJECT_S + j);
- emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j, obj, plane );
+ struct ureg plane =
+ register_param3(p, STATE_TEXGEN, i,
+ STATE_TEXGEN_OBJECT_S + j);
+
+ emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j,
+ obj, plane );
break;
}
case GL_EYE_LINEAR: {
struct ureg eye = get_eye_position(p);
- struct ureg plane = register_param3(p, STATE_TEXGEN, i, STATE_TEXGEN_EYE_S + j);
- emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j, eye, plane );
+ struct ureg plane =
+ register_param3(p, STATE_TEXGEN, i,
+ STATE_TEXGEN_EYE_S + j);
+
+ emit_op2(p, VP_OPCODE_DP4, out_texgen, WRITEMASK_X << j,
+ eye, plane );
break;
}
case GL_SPHERE_MAP:
if (sphere_mask) {
- struct ureg normal = get_eye_normal(p);
- struct ureg eye_hat = get_eye_position_normalized(p);
- struct ureg tmp = get_temp(p);
- struct ureg half = register_const1f(p, .5);
- struct ureg r = get_temp(p);
- struct ureg inv_m = get_temp(p);
-
- emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat); /* n.u */
- emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp); /* 2n.u */
- emit_op3(p, VP_OPCODE_MAD, r, 0, negate(tmp), normal, eye_hat); /* (-2n.u)n + u */
- emit_op2(p, VP_OPCODE_ADD, tmp, 0, r, swizzle(get_identity_param(p),X,Y,W,Z)); /* r + 0,0,1 */
- emit_op2(p, VP_OPCODE_DP3, tmp, 0, tmp, tmp); /* rx^2 + ry^2 + (rz+1)^2 */
- emit_op1(p, VP_OPCODE_RSQ, tmp, 0, tmp); /* 2/m */
- emit_op2(p, VP_OPCODE_MUL, inv_m, 0, tmp, swizzle1(half,X)); /* 1/m */
- emit_op3(p, VP_OPCODE_MAD, out_texgen, sphere_mask, r, inv_m, swizzle1(half,X)); /* r/m + 1/2 */
-
- release_temp(p, tmp);
- release_temp(p, r);
- release_temp(p, inv_m);
+ build_sphere_texgen(p, out_texgen, sphere_mask);
}
- /* Could duplicate the above calculations, but it would be
- * a fairly odd state for someone to set (both sphere and
- * reflection active for different texture coordinate
- * components. Of course - if two texture units enable
- * reflect and/or sphere, things start to tilt in favour
- * of seperating this out:
- */
if (reflect_mask) {
- struct ureg normal = get_eye_normal(p);
- struct ureg eye_hat = get_eye_position_normalized(p);
- struct ureg tmp = get_temp(p);
-
- emit_op2(p, VP_OPCODE_DP3, tmp, 0, normal, eye_hat);
- emit_op2(p, VP_OPCODE_ADD, tmp, 0, tmp, tmp);
- emit_op3(p, VP_OPCODE_MAD, out_texgen, reflect_mask, negate(tmp), normal, eye_hat);
+ build_reflect_texgen(p, out_texgen, reflect_mask);
}
if (normal_mask) {
if (texmat_enabled) {
struct ureg texmat[4];
- struct ureg in = !is_undef(out_texgen) ? out_texgen : register_input(p, VERT_ATTRIB_TEX0+i);
- register_matrix_param6( p, STATE_MATRIX, STATE_TEXTURE, i, 0, 3, 0, texmat );
+ struct ureg in = (!is_undef(out_texgen) ?
+ out_texgen :
+ register_input(p, VERT_ATTRIB_TEX0+i));
+ register_matrix_param6( p, STATE_MATRIX, STATE_TEXTURE, i,
+ 0, 3, 0, texmat );
emit_matrix_transform_vec4( p, out, texmat, in );
}
static void build_pointsize( struct tnl_program *p )
{
struct ureg eye = get_eye_position(p);
- struct ureg state_size = register_param1( p, STATE_POINT_SIZE );
- struct ureg state_attenuation = register_param1( p, STATE_POINT_ATTENUATION );
- struct ureg out = register_output( p, VERT_RESULT_PSIZ );
+ struct ureg state_size = register_param1(p, STATE_POINT_SIZE);
+ struct ureg state_attenuation = register_param1(p, STATE_POINT_ATTENUATION);
+ struct ureg out = register_output(p, VERT_RESULT_PSIZ);
struct ureg ut = get_temp(p);
/* 1, -Z, Z * Z, 1 */
emit_op2(p, VP_OPCODE_MUL, ut, WRITEMASK_Z, ut, negate(swizzle1(eye, Z)));
- /* p1 + p2 * dst + p3 * dst * dst, 0 */
+ /* p1 + p2 * dist + p3 * dist * dist, 0 */
emit_op2(p, VP_OPCODE_DP3, ut, 0, ut, state_attenuation);
/* 1 / factor */
projects / mesa.git / commitdiff