← Back to branch summary

~unity-team/nux/texture-atlas

« back to all changes in this revision

Viewing changes to NuxGraphics/RenderingPipeAsm.cpp

  • Committer: Nicolas d'Offay
  • Date: 2012-11-16 18:23:48 UTC
  • mfrom: (682.2.25 trunk)
  • Revision ID: nicolas.doffay@canonical.com-20121116182348-ygq13lkwgbugen04
Additional work to get the texture atlas class running as a normal texture.

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxGraphics/RenderingPipeAsm.cpp
102
102
 
103
103
  void GraphicsEngine::InitAsmColorShader()
104
104
  {
105
 
    NString AsmVtx = 
 
105
    const char* AsmVtx = 
106
106
        "!!ARBvp1.0                                 \n\
107
107
        ATTRIB iPos         = vertex.position;      \n\
108
108
        ATTRIB iColor       = vertex.attrib[3];     \n\
117
117
        MOV   oColor, iColor;            \n\
118
118
        END";
119
119
 
120
 
    NString AsmFrg = 
 
120
    const char* AsmFrg = 
121
121
        "!!ARBfp1.0                                     \n\
122
122
        MOV result.color, fragment.color;               \n\
123
123
        END";
124
124
 
125
125
    m_AsmColor = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
126
 
    m_AsmColor->LoadVertexShader(AsmVtx.GetTCharPtr());
127
 
    m_AsmColor->LoadPixelShader(AsmFrg.GetTCharPtr());
 
126
    m_AsmColor->LoadVertexShader(AsmVtx);
 
127
    m_AsmColor->LoadPixelShader(AsmFrg);
128
128
    m_AsmColor->Link();
129
129
  }
130
130
 
131
131
  void GraphicsEngine::InitAsmTextureShader()
132
132
  {
133
 
    NString AsmVtx = 
 
133
    const char* AsmVtx = 
134
134
        "!!ARBvp1.0                                 \n\
135
135
        ATTRIB iPos         = vertex.position;      \n\
136
136
        ATTRIB iColor       = vertex.attrib[3];     \n\
147
147
        MOV   oTexCoord0, vertex.attrib[8];             \n\
148
148
        END";
149
149
 
150
 
    NString AsmFrg = 
 
150
    const char* AsmFrg = 
151
151
        "!!ARBfp1.0                                       \n\
152
152
        TEMP tex0;                                        \n\
153
153
        TEX tex0, fragment.texcoord[0], texture[0], 2D;   \n\
154
154
        MUL result.color, fragment.color, tex0;           \n\
155
155
        END";
156
156
 
157
 
    NString AsmFrgRect = 
 
157
    const char* AsmFrgRect = 
158
158
      "!!ARBfp1.0                                       \n\
159
159
      TEMP tex0;                                        \n\
160
160
      TEX tex0, fragment.texcoord[0], texture[0], RECT; \n\
162
162
      END";
163
163
 
164
164
    m_AsmTextureModColor = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
165
 
    m_AsmTextureModColor->LoadVertexShader(AsmVtx.GetTCharPtr());
166
 
    m_AsmTextureModColor->LoadPixelShader(AsmFrg.GetTCharPtr());
 
165
    m_AsmTextureModColor->LoadVertexShader(AsmVtx);
 
166
    m_AsmTextureModColor->LoadPixelShader(AsmFrg);
167
167
    m_AsmTextureModColor->Link();
168
168
 
169
169
    m_AsmTextureRectModColor = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
170
 
    m_AsmTextureRectModColor->LoadVertexShader(AsmVtx.GetTCharPtr());
171
 
    m_AsmTextureRectModColor->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
170
    m_AsmTextureRectModColor->LoadVertexShader(AsmVtx);
 
171
    m_AsmTextureRectModColor->LoadPixelShader(AsmFrgRect);
172
172
    m_AsmTextureRectModColor->Link();
173
173
  }
174
174
 
175
175
  void GraphicsEngine::InitAsmColorModTexMaskAlpha()
176
176
  {
177
 
    NString AsmVtx = 
 
177
    const char* AsmVtx = 
178
178
        "!!ARBvp1.0                                 \n\
179
179
        OUTPUT oPos         = result.position;      \n\
180
180
        OUTPUT oColor       = result.color;         \n\
188
188
        MOV   oTexCoord0, vertex.attrib[8];         \n\
189
189
        END";
190
190
 
191
 
    NString AsmFrg = 
 
191
    const char* AsmFrg = 
192
192
      "!!ARBfp1.0                                         \n\
193
193
      TEMP tex0;                                          \n\
194
194
      TEMP temp;                                          \n\
198
198
      MOV result.color, temp;                             \n\
199
199
      END";
200
200
 
201
 
    NString AsmFrgRect = 
 
201
    const char* AsmFrgRect = 
202
202
      "!!ARBfp1.0                                         \n\
203
203
      TEMP tex0;                                          \n\
204
204
      TEMP temp;                                          \n\
209
209
      END";
210
210
 
211
211
    m_AsmColorModTexMaskAlpha = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
212
 
    m_AsmColorModTexMaskAlpha->LoadVertexShader(AsmVtx.GetTCharPtr());
213
 
    m_AsmColorModTexMaskAlpha->LoadPixelShader(AsmFrg.GetTCharPtr());
 
212
    m_AsmColorModTexMaskAlpha->LoadVertexShader(AsmVtx);
 
213
    m_AsmColorModTexMaskAlpha->LoadPixelShader(AsmFrg);
214
214
    m_AsmColorModTexMaskAlpha->Link();
215
215
 
216
216
    m_AsmColorModTexRectMaskAlpha = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
217
 
    m_AsmColorModTexRectMaskAlpha->LoadVertexShader(AsmVtx.GetTCharPtr());
218
 
    m_AsmColorModTexRectMaskAlpha->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
217
    m_AsmColorModTexRectMaskAlpha->LoadVertexShader(AsmVtx);
 
218
    m_AsmColorModTexRectMaskAlpha->LoadPixelShader(AsmFrgRect);
219
219
    m_AsmColorModTexRectMaskAlpha->Link();
220
220
  }
221
221
 
222
222
  void GraphicsEngine::InitAsm2TextureAdd()
223
223
  {
224
 
    NString AsmVtx = 
 
224
    const char* AsmVtx = 
225
225
        "!!ARBvp1.0                                 \n\
226
226
        ATTRIB iPos         = vertex.position;      \n\
227
227
        OUTPUT oPos         = result.position;      \n\
236
236
        MOV   oTexCoord1, vertex.attrib[9];       \n\
237
237
        END";
238
238
 
239
 
    NString AsmFrg = 
 
239
    const char* AsmFrg = 
240
240
        "!!ARBfp1.0                                         \n\
241
241
        PARAM color0 = program.local[0];                    \n\
242
242
        PARAM color1 = program.local[1];                    \n\
250
250
        MOV result.color, temp;                             \n\
251
251
        END";
252
252
 
253
 
    NString AsmFrgRect = 
 
253
    const char* AsmFrgRect = 
254
254
      "!!ARBfp1.0                                         \n\
255
255
      PARAM color0 = program.local[0];                    \n\
256
256
      PARAM color1 = program.local[1];                    \n\
265
265
      END";
266
266
 
267
267
    m_Asm2TextureAdd = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
268
 
    m_Asm2TextureAdd->LoadVertexShader(AsmVtx.GetTCharPtr());
269
 
    m_Asm2TextureAdd->LoadPixelShader(AsmFrg.GetTCharPtr());
 
268
    m_Asm2TextureAdd->LoadVertexShader(AsmVtx);
 
269
    m_Asm2TextureAdd->LoadPixelShader(AsmFrg);
270
270
    m_Asm2TextureAdd->Link();
271
271
 
272
272
    m_Asm2TextureRectAdd = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
273
 
    m_Asm2TextureRectAdd->LoadVertexShader(AsmVtx.GetTCharPtr());
274
 
    m_Asm2TextureRectAdd->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
273
    m_Asm2TextureRectAdd->LoadVertexShader(AsmVtx);
 
274
    m_Asm2TextureRectAdd->LoadPixelShader(AsmFrgRect);
275
275
    m_Asm2TextureRectAdd->Link();
276
276
  }
277
277
 
278
278
  void GraphicsEngine::InitAsm2TextureDepRead()
279
279
  {
280
 
    NString AsmVtx = 
 
280
    const char* AsmVtx = 
281
281
      "!!ARBvp1.0                                 \n\
282
282
      ATTRIB iPos         = vertex.position;      \n\
283
283
      OUTPUT oPos         = result.position;      \n\
292
292
      MOV   oTexCoord1, vertex.attrib[9];       \n\
293
293
      END";
294
294
 
295
 
    NString AsmFrg = 
 
295
    const char* AsmFrg = 
296
296
      "!!ARBfp1.0                                         \n\
297
297
      PARAM color0 = program.local[0];                    \n\
298
298
      PARAM color1 = program.local[1];                    \n\
309
309
      MUL result.color, color1, tex1;                     \n\
310
310
      END";
311
311
 
312
 
    NString AsmFrgRect = 
 
312
    const char* AsmFrgRect = 
313
313
      "!!ARBfp1.0                                         \n\
314
314
      PARAM color0 = program.local[0];                    \n\
315
315
      PARAM color1 = program.local[1];                    \n\
324
324
      END";
325
325
 
326
326
    m_ASM2TextureDepRead = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
327
 
    m_ASM2TextureDepRead->LoadVertexShader(AsmVtx.GetTCharPtr());
328
 
    m_ASM2TextureDepRead->LoadPixelShader(AsmFrg.GetTCharPtr());
 
327
    m_ASM2TextureDepRead->LoadVertexShader(AsmVtx);
 
328
    m_ASM2TextureDepRead->LoadPixelShader(AsmFrg);
329
329
    m_ASM2TextureDepRead->Link();
330
330
 
331
331
    m_ASM2TextureRectDepRead = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
332
 
    m_ASM2TextureRectDepRead->LoadVertexShader(AsmVtx.GetTCharPtr());
333
 
    m_ASM2TextureRectDepRead->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
332
    m_ASM2TextureRectDepRead->LoadVertexShader(AsmVtx);
 
333
    m_ASM2TextureRectDepRead->LoadPixelShader(AsmFrgRect);
334
334
    m_ASM2TextureRectDepRead->Link();
335
335
  }
336
336
 
337
337
  void GraphicsEngine::InitAsm2TextureMod()
338
338
  {
339
 
    NString AsmVtx = 
 
339
    const char* AsmVtx = 
340
340
      "!!ARBvp1.0                                 \n\
341
341
      ATTRIB iPos         = vertex.position;      \n\
342
342
      OUTPUT oPos         = result.position;      \n\
351
351
      MOV   oTexCoord1, vertex.attrib[9];       \n\
352
352
      END";
353
353
 
354
 
    NString AsmFrg = 
 
354
    const char* AsmFrg = 
355
355
      "!!ARBfp1.0                                         \n\
356
356
      PARAM color0 = program.local[0];                    \n\
357
357
      PARAM color1 = program.local[1];                    \n\
366
366
      MUL result.color, temp0, temp1;                     \n\
367
367
      END";
368
368
 
369
 
    NString AsmFrgRect = 
 
369
    const char* AsmFrgRect = 
370
370
      "!!ARBfp1.0                                         \n\
371
371
      PARAM color0 = program.local[0];                    \n\
372
372
      PARAM color1 = program.local[1];                    \n\
382
382
      END";
383
383
 
384
384
    m_Asm2TextureMod = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
385
 
    m_Asm2TextureMod->LoadVertexShader(AsmVtx.GetTCharPtr());
386
 
    m_Asm2TextureMod->LoadPixelShader(AsmFrg.GetTCharPtr());
 
385
    m_Asm2TextureMod->LoadVertexShader(AsmVtx);
 
386
    m_Asm2TextureMod->LoadPixelShader(AsmFrg);
387
387
    m_Asm2TextureMod->Link();
388
388
 
389
389
    m_Asm2TextureRectMod = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
390
 
    m_Asm2TextureRectMod->LoadVertexShader(AsmVtx.GetTCharPtr());
391
 
    m_Asm2TextureRectMod->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
390
    m_Asm2TextureRectMod->LoadVertexShader(AsmVtx);
 
391
    m_Asm2TextureRectMod->LoadPixelShader(AsmFrgRect);
392
392
    m_Asm2TextureRectMod->Link();
393
393
  }
394
394
 
395
395
  void GraphicsEngine::InitAsm4TextureAdd()
396
396
  {
397
 
    NString AsmVtx = 
 
397
    const char* AsmVtx = 
398
398
        "!!ARBvp1.0                                 \n\
399
399
        ATTRIB iPos         = vertex.position;      \n\
400
400
        OUTPUT oPos         = result.position;      \n\
413
413
        MOV   oTexCoord3, vertex.attrib[11];       \n\
414
414
        END";
415
415
 
416
 
    NString AsmFrg = 
 
416
    const char* AsmFrg = 
417
417
        "!!ARBfp1.0                                         \n\
418
418
        PARAM color0 = program.local[0];                    \n\
419
419
        PARAM color1 = program.local[1];                    \n\
435
435
        MOV result.color, temp;                             \n\
436
436
        END";
437
437
 
438
 
    NString AsmFrgRect = 
 
438
    const char* AsmFrgRect = 
439
439
      "!!ARBfp1.0                                         \n\
440
440
      PARAM color0 = program.local[0];                    \n\
441
441
      PARAM color1 = program.local[1];                    \n\
458
458
      END";
459
459
 
460
460
    m_Asm4TextureAdd = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
461
 
    m_Asm4TextureAdd->LoadVertexShader(AsmVtx.GetTCharPtr());
462
 
    m_Asm4TextureAdd->LoadPixelShader(AsmFrg.GetTCharPtr());
 
461
    m_Asm4TextureAdd->LoadVertexShader(AsmVtx);
 
462
    m_Asm4TextureAdd->LoadPixelShader(AsmFrg);
463
463
    m_Asm4TextureAdd->Link();
464
464
 
465
465
    m_Asm4TextureRectAdd = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
466
 
    m_Asm4TextureRectAdd->LoadVertexShader(AsmVtx.GetTCharPtr());
467
 
    m_Asm4TextureRectAdd->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
466
    m_Asm4TextureRectAdd->LoadVertexShader(AsmVtx);
 
467
    m_Asm4TextureRectAdd->LoadPixelShader(AsmFrgRect);
468
468
    m_Asm4TextureRectAdd->Link();
469
469
  }
470
470
 
471
471
  void GraphicsEngine::InitAsmBlendModes()
472
472
  {
473
 
    NString AsmVtx = 
 
473
    const char* AsmVtx = 
474
474
                       "!!ARBvp1.0                                 \n\
475
475
        OUTPUT oPos         = result.position;      \n\
476
476
        OUTPUT oTexCoord0   = result.texcoord[0];   \n\
484
484
        MOV   oTexCoord1, vertex.attrib[9];       \n\
485
485
        END";
486
486
 
487
 
    NString AsmPSBNormal = 
 
487
    const char* AsmPSBNormal = 
488
488
                             "!!ARBfp1.0                                         \n\
489
489
        TEMP tex0;                                          \n\
490
490
        TEMP tex1;                                          \n\
494
494
        END";
495
495
 
496
496
    m_AsmPSBNormal = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
497
 
    m_AsmPSBNormal->LoadVertexShader(AsmVtx.GetTCharPtr());
498
 
    m_AsmPSBNormal->LoadPixelShader(AsmPSBNormal.GetTCharPtr());
 
497
    m_AsmPSBNormal->LoadVertexShader(AsmVtx);
 
498
    m_AsmPSBNormal->LoadPixelShader(AsmPSBNormal);
499
499
    m_AsmPSBNormal->Link();
500
500
 
501
501
    // Lighten
502
 
    NString AsmPSBLighten = 
 
502
    const char* AsmPSBLighten = 
503
503
                              "!!ARBfp1.0                                         \n\
504
504
        TEMP tex0;                                          \n\
505
505
        TEMP tex1;                                          \n\
513
513
        END";
514
514
 
515
515
    m_AsmPSBLighten = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
516
 
    m_AsmPSBLighten->LoadVertexShader(AsmVtx.GetTCharPtr());
517
 
    m_AsmPSBLighten->LoadPixelShader(AsmPSBLighten.GetTCharPtr());
 
516
    m_AsmPSBLighten->LoadVertexShader(AsmVtx);
 
517
    m_AsmPSBLighten->LoadPixelShader(AsmPSBLighten);
518
518
    m_AsmPSBLighten->Link();
519
519
 
520
520
    // Darken
521
 
    NString AsmPSBDarken = 
 
521
    const char* AsmPSBDarken = 
522
522
                             "!!ARBfp1.0                                         \n\
523
523
        TEMP tex0;                                          \n\
524
524
        TEMP tex1;                                          \n\
532
532
        END";
533
533
 
534
534
    m_AsmPSBDarken = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
535
 
    m_AsmPSBDarken->LoadVertexShader(AsmVtx.GetTCharPtr());
536
 
    m_AsmPSBDarken->LoadPixelShader(AsmPSBDarken.GetTCharPtr());
 
535
    m_AsmPSBDarken->LoadVertexShader(AsmVtx);
 
536
    m_AsmPSBDarken->LoadPixelShader(AsmPSBDarken);
537
537
    m_AsmPSBDarken->Link();
538
538
 
539
539
    // Multiply
540
 
    NString AsmPSBMultiply = 
 
540
    const char* AsmPSBMultiply = 
541
541
                               "!!ARBfp1.0                                         \n\
542
542
        TEMP tex0;                                          \n\
543
543
        TEMP tex1;                                          \n\
548
548
        END";
549
549
 
550
550
    m_AsmPSBMultiply = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
551
 
    m_AsmPSBMultiply->LoadVertexShader(AsmVtx.GetTCharPtr());
552
 
    m_AsmPSBMultiply->LoadPixelShader(AsmPSBMultiply.GetTCharPtr());
 
551
    m_AsmPSBMultiply->LoadVertexShader(AsmVtx);
 
552
    m_AsmPSBMultiply->LoadPixelShader(AsmPSBMultiply);
553
553
    m_AsmPSBMultiply->Link();
554
554
  }
555
555
 
1241
1241
 
1242
1242
  void GraphicsEngine::InitAsmPower()
1243
1243
  {
1244
 
    NString AsmVtx = 
 
1244
    const char* AsmVtx = 
1245
1245
      "!!ARBvp1.0                                 \n\
1246
1246
      ATTRIB iPos         = vertex.position;      \n\
1247
1247
      OUTPUT oPos         = result.position;      \n\
1255
1255
      END";
1256
1256
 
1257
1257
 
1258
 
    NString AsmFrg = 
 
1258
    const char* AsmFrg = 
1259
1259
      "!!ARBfp1.0                                       \n\
1260
1260
      PARAM color0 = program.local[0];                  \n\
1261
1261
      PARAM exponent = program.local[1];                \n\
1269
1269
      MUL result.color, color0, final;             \n\
1270
1270
      END";
1271
1271
 
1272
 
    NString AsmFrgRect = 
1273
 
      "!!ARBfp1.0                                       \n\
1274
 
      PARAM color0 = program.local[0];                  \n\
1275
 
      PARAM exponent = program.local[1];                \n\
1276
 
      TEMP tex0;                                        \n\
1277
 
      TEMP final;                                       \n\
1278
 
      TEX tex0, fragment.texcoord[0], texture[0], RECT;   \n\
1279
 
      POW final.r, tex0.r, exponent.r;             \n\
1280
 
      POW final.g, tex0.g, exponent.g;             \n\
1281
 
      POW final.b, tex0.b, exponent.b;             \n\
1282
 
      MOV final.a, tex0.a;                         \n\
1283
 
      MUL result.color, color0, final;             \n\
1284
 
      END";
1285
 
 
1286
1272
    _asm_tex_component_exponentiation_prog = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
1287
 
    _asm_tex_component_exponentiation_prog->LoadVertexShader(AsmVtx.GetTCharPtr());
1288
 
    _asm_tex_component_exponentiation_prog->LoadPixelShader(AsmFrg.GetTCharPtr());
 
1273
    _asm_tex_component_exponentiation_prog->LoadVertexShader(AsmVtx);
 
1274
    _asm_tex_component_exponentiation_prog->LoadPixelShader(AsmFrg);
1289
1275
    _asm_tex_component_exponentiation_prog->Link();
1290
1276
  }
1291
1277
 
1351
1337
 
1352
1338
  void GraphicsEngine::InitAsmAlphaReplicate()
1353
1339
  {
1354
 
    NString AsmVtx = 
 
1340
    const char* AsmVtx = 
1355
1341
      "!!ARBvp1.0                                 \n\
1356
1342
      ATTRIB iPos         = vertex.position;      \n\
1357
1343
      OUTPUT oPos         = result.position;      \n\
1365
1351
      END";
1366
1352
 
1367
1353
 
1368
 
    NString AsmFrg = 
 
1354
    const char* AsmFrg = 
1369
1355
      "!!ARBfp1.0                                     \n\
1370
1356
      PARAM color0 = program.local[0];                \n\
1371
1357
      TEMP tex0;                                      \n\
1373
1359
      MUL result.color, color0, tex0.aaaa;            \n\
1374
1360
      END";
1375
1361
 
1376
 
    NString AsmFrgRect = 
1377
 
      "!!ARBfp1.0                                       \n\
1378
 
      PARAM color0 = program.local[0];                  \n\
1379
 
      TEMP tex0;                                        \n\
1380
 
      TEX tex0, fragment.texcoord[0], texture[0], RECT; \n\
1381
 
      MUL result.color, color0, tex0.aaaa;              \n\
1382
 
      END";
1383
 
 
1384
1362
    _asm_tex_alpha_replicate_prog = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
1385
 
    _asm_tex_alpha_replicate_prog->LoadVertexShader(AsmVtx.GetTCharPtr());
1386
 
    _asm_tex_alpha_replicate_prog->LoadPixelShader(AsmFrg.GetTCharPtr());
 
1363
    _asm_tex_alpha_replicate_prog->LoadVertexShader(AsmVtx);
 
1364
    _asm_tex_alpha_replicate_prog->LoadPixelShader(AsmFrg);
1387
1365
    _asm_tex_alpha_replicate_prog->Link();
1388
1366
 
1389
1367
  }
1450
1428
 
1451
1429
  void GraphicsEngine::InitAsmColorMatrixFilter()
1452
1430
  {
1453
 
    NString AsmVtx = 
 
1431
    const char* AsmVtx = 
1454
1432
      "!!ARBvp1.0                                               \n\
1455
1433
      ATTRIB iPos         = vertex.position;                    \n\
1456
1434
      OUTPUT oPos         = result.position;                    \n\
1464
1442
      END";
1465
1443
 
1466
1444
 
1467
 
    NString AsmFrg = 
 
1445
    const char* AsmFrg = 
1468
1446
      "!!ARBfp1.0                                     \n\
1469
1447
      PARAM color0 = program.local[0];                \n\
1470
1448
      PARAM CM0 = program.local[1];                   \n\
1482
1460
      MUL result.color, color0, final;                \n\
1483
1461
      END";
1484
1462
 
1485
 
    NString AsmFrgRect = 
 
1463
    const char* AsmFrgRect = 
1486
1464
      "!!ARBfp1.0                                     \n\
1487
1465
      PARAM color0 = program.local[0];                \n\
1488
1466
      PARAM CM0 = program.local[1];                   \n\
1501
1479
      END";
1502
1480
 
1503
1481
    _asm_tex_color_matrix_filter_prog = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
1504
 
    _asm_tex_color_matrix_filter_prog->LoadVertexShader(AsmVtx.GetTCharPtr());
1505
 
    _asm_tex_color_matrix_filter_prog->LoadPixelShader(AsmFrg.GetTCharPtr());
 
1482
    _asm_tex_color_matrix_filter_prog->LoadVertexShader(AsmVtx);
 
1483
    _asm_tex_color_matrix_filter_prog->LoadPixelShader(AsmFrg);
1506
1484
    _asm_tex_color_matrix_filter_prog->Link();
1507
1485
 
1508
1486
    _asm_texrect_color_matrix_filter_prog = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
1509
 
    _asm_texrect_color_matrix_filter_prog->LoadVertexShader(AsmVtx.GetTCharPtr());
1510
 
    _asm_texrect_color_matrix_filter_prog->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
1487
    _asm_texrect_color_matrix_filter_prog->LoadVertexShader(AsmVtx);
 
1488
    _asm_texrect_color_matrix_filter_prog->LoadPixelShader(AsmFrgRect);
1511
1489
    _asm_texrect_color_matrix_filter_prog->Link();
1512
1490
  }
1513
1491
 
1578
1556
 
1579
1557
  void GraphicsEngine::InitAsmSeparableGaussFilter()
1580
1558
  {
1581
 
    NString AsmVtx = 
 
1559
    const char* AsmVtx = 
1582
1560
      "!!ARBvp1.0                                 \n\
1583
1561
      ATTRIB iPos         = vertex.position;      \n\
1584
1562
      OUTPUT oPos         = result.position;      \n\
1604
1582
      END";
1605
1583
 
1606
1584
 
1607
 
    NString AsmFrg = 
 
1585
    const char* AsmFrg = 
1608
1586
      "!!ARBfp1.0                                                   \n\
1609
1587
      TEMP tex0;                                                    \n\
1610
1588
      TEMP final;                                                   \n\
1627
1605
      END";
1628
1606
 
1629
1607
 
1630
 
    NString AsmFrgRect = 
 
1608
    const char* AsmFrgRect = 
1631
1609
      "!!ARBfp1.0                                                   \n\
1632
1610
      TEMP tex0;                                                    \n\
1633
1611
      TEMP final;                                                   \n\
1650
1628
      END";
1651
1629
 
1652
1630
    _asm_tex_separable_gauss_filter_prog = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
1653
 
    _asm_tex_separable_gauss_filter_prog->LoadVertexShader(AsmVtx.GetTCharPtr());
1654
 
    _asm_tex_separable_gauss_filter_prog->LoadPixelShader(AsmFrg.GetTCharPtr());
 
1631
    _asm_tex_separable_gauss_filter_prog->LoadVertexShader(AsmVtx);
 
1632
    _asm_tex_separable_gauss_filter_prog->LoadPixelShader(AsmFrg);
1655
1633
    _asm_tex_separable_gauss_filter_prog->Link();
1656
1634
 
1657
1635
    _asm_texrect_separable_gauss_filter_prog = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
1658
 
    _asm_texrect_separable_gauss_filter_prog->LoadVertexShader(AsmVtx.GetTCharPtr());
1659
 
    _asm_texrect_separable_gauss_filter_prog->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
1636
    _asm_texrect_separable_gauss_filter_prog->LoadVertexShader(AsmVtx);
 
1637
    _asm_texrect_separable_gauss_filter_prog->LoadPixelShader(AsmFrgRect);
1660
1638
    _asm_texrect_separable_gauss_filter_prog->Link();
1661
1639
  }
1662
1640
 
2287
2265
 
2288
2266
  void GraphicsEngine::InitAsmPixelateShader()
2289
2267
  {
2290
 
    NString AsmVtx = 
 
2268
    const char* AsmVtx = 
2291
2269
      "!!ARBvp1.0                                 \n\
2292
2270
      ATTRIB iPos         = vertex.position;      \n\
2293
2271
      ATTRIB iColor       = vertex.attrib[3];     \n\
2304
2282
      MOV   oTexCoord0, vertex.attrib[8];             \n\
2305
2283
      END";
2306
2284
 
2307
 
    NString AsmFrg = 
 
2285
    const char* AsmFrg = 
2308
2286
      "!!ARBfp1.0                                       \n\
2309
2287
      TEMP tex0;                                        \n\
2310
2288
      TEMP tex_coord;                                   \n\
2317
2295
      MUL result.color, fragment.color, tex0;           \n\
2318
2296
      END";
2319
2297
 
2320
 
    NString AsmFrgRect = 
 
2298
    const char* AsmFrgRect = 
2321
2299
      "!!ARBfp1.0                                       \n\
2322
2300
      TEMP tex0;                                        \n\
2323
2301
      TEMP tex_coord;                                   \n\
2331
2309
      END";
2332
2310
 
2333
2311
    m_AsmPixelate = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
2334
 
    m_AsmPixelate->LoadVertexShader(AsmVtx.GetTCharPtr());
2335
 
    m_AsmPixelate->LoadPixelShader(AsmFrg.GetTCharPtr());
 
2312
    m_AsmPixelate->LoadVertexShader(AsmVtx);
 
2313
    m_AsmPixelate->LoadPixelShader(AsmFrg);
2336
2314
    m_AsmPixelate->Link();
2337
2315
 
2338
2316
    m_AsmPixelateRect = GetGraphicsDisplay()->GetGpuDevice()->CreateAsmShaderProgram();
2339
 
    m_AsmPixelateRect->LoadVertexShader(AsmVtx.GetTCharPtr());
2340
 
    m_AsmPixelateRect->LoadPixelShader(AsmFrgRect.GetTCharPtr());
 
2317
    m_AsmPixelateRect->LoadVertexShader(AsmVtx);
 
2318
    m_AsmPixelateRect->LoadPixelShader(AsmFrgRect);
2341
2319
    m_AsmPixelateRect->Link();
2342
2320
  }
2343
2321