← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/gallium/state_trackers/vega/api_params.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/state_trackers/vega/api_params.c
32
32
#include "image.h"
33
33
#include "matrix.h"
34
34
#include "api_consts.h"
 
35
#include "api.h"
35
36
 
36
37
#include "pipe/p_compiler.h"
37
38
#include "util/u_pointer.h"
63
64
   }
64
65
}
65
66
 
66
 
void vgSetf (VGParamType type, VGfloat value)
 
67
void vegaSetf (VGParamType type, VGfloat value)
67
68
{
68
69
   struct vg_context *ctx = vg_current_context();
69
70
   struct vg_state *state = current_state();
123
124
   vg_set_error(ctx, error);
124
125
}
125
126
 
126
 
void vgSeti (VGParamType type, VGint value)
 
127
void vegaSeti (VGParamType type, VGint value)
127
128
{
128
129
   struct vg_context *ctx = vg_current_context();
129
130
   struct vg_state *state = current_state();
254
255
   vg_set_error(ctx, error);
255
256
}
256
257
 
257
 
void vgSetfv(VGParamType type, VGint count,
258
 
             const VGfloat * values)
 
258
void vegaSetfv(VGParamType type, VGint count,
 
259
               const VGfloat * values)
259
260
{
260
261
   struct vg_context *ctx = vg_current_context();
261
262
   struct vg_state *state = current_state();
382
383
   vg_set_error(ctx, error);
383
384
}
384
385
 
385
 
void vgSetiv(VGParamType type, VGint count,
386
 
             const VGint * values)
 
386
void vegaSetiv(VGParamType type, VGint count,
 
387
               const VGint * values)
387
388
{
388
389
   struct vg_context *ctx = vg_current_context();
389
390
   struct vg_state *state = current_state();
506
507
   }
507
508
}
508
509
 
509
 
VGfloat vgGetf(VGParamType type)
 
510
VGfloat vegaGetf(VGParamType type)
510
511
{
511
512
   struct vg_context *ctx = vg_current_context();
512
513
   const struct vg_state *state = current_state();
568
569
   return value;
569
570
}
570
571
 
571
 
VGint vgGeti(VGParamType type)
 
572
VGint vegaGeti(VGParamType type)
572
573
{
573
574
   const struct vg_state *state = current_state();
574
575
   struct vg_context *ctx = vg_current_context();
683
684
   return value;
684
685
}
685
686
 
686
 
VGint vgGetVectorSize(VGParamType type)
 
687
VGint vegaGetVectorSize(VGParamType type)
687
688
{
688
689
   struct vg_context *ctx = vg_current_context();
689
690
   const struct vg_state *state = current_state();
757
758
   }
758
759
}
759
760
 
760
 
void vgGetfv(VGParamType type, VGint count,
761
 
             VGfloat * values)
 
761
void vegaGetfv(VGParamType type, VGint count,
 
762
               VGfloat * values)
762
763
{
763
764
   const struct vg_state *state = current_state();
764
765
   struct vg_context *ctx = vg_current_context();
858
859
   }
859
860
}
860
861
 
861
 
void vgGetiv(VGParamType type, VGint count,
862
 
             VGint * values)
 
862
void vegaGetiv(VGParamType type, VGint count,
 
863
               VGint * values)
863
864
{
864
865
   const struct vg_state *state = current_state();
865
866
   struct vg_context *ctx = vg_current_context();
964
965
   }
965
966
}
966
967
 
967
 
void vgSetParameterf(VGHandle object,
968
 
                     VGint paramType,
969
 
                     VGfloat value)
 
968
void vegaSetParameterf(VGHandle object,
 
969
                       VGint paramType,
 
970
                       VGfloat value)
970
971
{
971
972
   struct vg_context *ctx = vg_current_context();
972
973
   void *ptr = (void*)object;
1018
1019
   }
1019
1020
}
1020
1021
 
1021
 
void vgSetParameteri(VGHandle object,
1022
 
                     VGint paramType,
1023
 
                     VGint value)
 
1022
void vegaSetParameteri(VGHandle object,
 
1023
                       VGint paramType,
 
1024
                       VGint value)
1024
1025
{
1025
1026
   struct vg_context *ctx = vg_current_context();
1026
1027
   void *ptr = (void*)object;
1093
1094
   }
1094
1095
}
1095
1096
 
1096
 
void vgSetParameterfv(VGHandle object,
1097
 
                      VGint paramType,
1098
 
                      VGint count,
1099
 
                      const VGfloat * values)
 
1097
void vegaSetParameterfv(VGHandle object,
 
1098
                        VGint paramType,
 
1099
                        VGint count,
 
1100
                        const VGfloat * values)
1100
1101
{
1101
1102
   struct vg_context *ctx = vg_current_context();
1102
1103
   void *ptr = (void*)object;
1206
1207
   }
1207
1208
}
1208
1209
 
1209
 
void vgSetParameteriv(VGHandle object,
1210
 
                      VGint paramType,
1211
 
                      VGint count,
1212
 
                      const VGint * values)
 
1210
void vegaSetParameteriv(VGHandle object,
 
1211
                        VGint paramType,
 
1212
                        VGint count,
 
1213
                        const VGint * values)
1213
1214
{
1214
1215
   struct vg_context *ctx = vg_current_context();
1215
1216
   void *ptr = (void*)object;
1311
1312
   }
1312
1313
}
1313
1314
 
1314
 
VGint vgGetParameterVectorSize(VGHandle object,
1315
 
                               VGint paramType)
 
1315
VGint vegaGetParameterVectorSize(VGHandle object,
 
1316
                                 VGint paramType)
1316
1317
{
1317
1318
   struct vg_context *ctx = vg_current_context();
1318
1319
   void *ptr = (void*)object;
1367
1368
}
1368
1369
 
1369
1370
 
1370
 
VGfloat vgGetParameterf(VGHandle object,
1371
 
                        VGint paramType)
 
1371
VGfloat vegaGetParameterf(VGHandle object,
 
1372
                          VGint paramType)
1372
1373
{
1373
1374
   struct vg_context *ctx = vg_current_context();
1374
1375
   void *ptr = (void*)object;
1424
1425
   return 0;
1425
1426
}
1426
1427
 
1427
 
VGint vgGetParameteri(VGHandle object,
1428
 
                      VGint paramType)
 
1428
VGint vegaGetParameteri(VGHandle object,
 
1429
                        VGint paramType)
1429
1430
{
1430
1431
   struct vg_context *ctx = vg_current_context();
1431
1432
   void *ptr = (void*)object;
1511
1512
   return 0;
1512
1513
}
1513
1514
 
1514
 
void vgGetParameterfv(VGHandle object,
1515
 
                      VGint paramType,
1516
 
                      VGint count,
1517
 
                      VGfloat * values)
 
1515
void vegaGetParameterfv(VGHandle object,
 
1516
                        VGint paramType,
 
1517
                        VGint count,
 
1518
                        VGfloat * values)
1518
1519
{
1519
1520
   struct vg_context *ctx = vg_current_context();
1520
1521
   void *ptr = (void*)object;
1598
1599
   }
1599
1600
}
1600
1601
 
1601
 
void vgGetParameteriv(VGHandle object,
1602
 
                      VGint paramType,
1603
 
                      VGint count,
1604
 
                      VGint * values)
 
1602
void vegaGetParameteriv(VGHandle object,
 
1603
                        VGint paramType,
 
1604
                        VGint count,
 
1605
                        VGint * values)
1605
1606
{
1606
1607
   struct vg_context *ctx = vg_current_context();
1607
1608
   void *ptr = (void*)object;