← Back to branch summary

~ubuntu-branches/ubuntu/breezy/aqsis/breezy

« back to all changes in this revision

Viewing changes to libshadervm/shadervm1.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Will Newton
  • Date: 2004-12-07 20:06:49 UTC
  • Revision ID: james.westby@ubuntu.com-20041207200649-fccswkrvp4oc8lmn
Tags: upstream-0.9.3
Import upstream version 0.9.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
libshadervm/shadervm1.cpp
 
1
// Aqsis
 
2
// Copyright � 1997 - 2001, Paul C. Gregory
 
3
//
 
4
// Contact: pgregory@aqsis.com
 
5
//
 
6
// This library is free software; you can redistribute it and/or
 
7
// modify it under the terms of the GNU General Public
 
8
// License as published by the Free Software Foundation; either
 
9
// version 2 of the License, or (at your option) any later version.
 
10
//
 
11
// This library is distributed in the hope that it will be useful,
 
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
// General Public License for more details.
 
15
//
 
16
// You should have received a copy of the GNU General Public
 
17
// License along with this library; if not, write to the Free Software
 
18
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 
 
20
 
 
21
/** \file
 
22
                \brief Implements functions for the shader virtual machine.
 
23
                \author Paul C. Gregory (pgregory@aqsis.com)
 
24
*/
 
25
 
 
26
#include        "aqsis.h"
 
27
 
 
28
#include        <iostream>
 
29
 
 
30
#include        <ctype.h>
 
31
 
 
32
#include        "shadervm.h"
 
33
#include        "logging.h"
 
34
 
 
35
START_NAMESPACE( Aqsis )
 
36
 
 
37
void CqShaderVM::SO_nop()
 
38
{}
 
39
 
 
40
void CqShaderVM::SO_dup()
 
41
{
 
42
    Dup();
 
43
}
 
44
 
 
45
void CqShaderVM::SO_drop()
 
46
{
 
47
    Drop();
 
48
}
 
49
 
 
50
void CqShaderVM::SO_debug_break()
 
51
{}
 
52
 
 
53
void CqShaderVM::SO_pushif()
 
54
{
 
55
    AUTOFUNC;
 
56
    RESULT(type_float, class_uniform);
 
57
    pResult->SetFloat( ReadNext().m_FloatVal );
 
58
    Push( pResult );
 
59
}
 
60
 
 
61
void CqShaderVM::SO_puship()
 
62
{
 
63
    AUTOFUNC;
 
64
    TqFloat f = ReadNext().m_FloatVal;
 
65
    TqFloat f2 = ReadNext().m_FloatVal;
 
66
    TqFloat f3 = ReadNext().m_FloatVal;
 
67
    RESULT(type_point, class_uniform);
 
68
    CqVector3D v(f,f2,f3);
 
69
    pResult->SetValue(v);
 
70
    Push( pResult );
 
71
}
 
72
 
 
73
void CqShaderVM::SO_pushis()
 
74
{
 
75
    AUTOFUNC;
 
76
    RESULT(type_string, class_uniform);
 
77
    CqString * ps = ReadNext().m_pString;
 
78
    pResult->SetValue( *ps );
 
79
    Push( pResult );
 
80
}
 
81
 
 
82
void CqShaderVM::SO_pushv()
 
83
{
 
84
    PushV( GetVar( ReadNext().m_iVariable ) );
 
85
}
 
86
 
 
87
void CqShaderVM::SO_ipushv()
 
88
{
 
89
    AUTOFUNC;
 
90
    POPV( A );  // Index
 
91
    IqShaderData* pVar = GetVar( ReadNext().m_iVariable );
 
92
    if ( pVar->ArrayLength() == 0 )
 
93
    {
 
94
        // Report error.
 
95
        std::cerr << critical << "Attempt to index a non array variable" << std::endl;
 
96
        return ;
 
97
    }
 
98
        //If either the value or the index is varying, so must the result be.
 
99
        RESULT(pVar->Type(), (pVar->Size()>1 || A->Size()>1)?class_varying:class_uniform);
 
100
    TqInt ext = m_pEnv->GridSize();
 
101
    TqBool fVarying = ext > 1;
 
102
    TqInt i;
 
103
    CqBitVector& RS = m_pEnv->RunningState();
 
104
    for ( i = 0; i < ext; i++ )
 
105
    {
 
106
        if(!fVarying || RS.Value( i ))
 
107
                {
 
108
                        TqFloat _aq_A;
 
109
                        A->GetFloat( _aq_A, i );
 
110
                        pResult->SetValueFromVariable( pVar->ArrayEntry( static_cast<unsigned int>( _aq_A ) ), i );
 
111
                }
 
112
    }
 
113
    Push( pResult );
 
114
    RELEASE( A );
 
115
}
 
116
 
 
117
void CqShaderVM::SO_pop()
 
118
{
 
119
    AUTOFUNC;
 
120
    IqShaderData* pV = GetVar( ReadNext().m_iVariable );
 
121
    POPV( Val );
 
122
    TqUint ext = MAX( m_pEnv->GridSize(), pV->Size() );
 
123
    TqBool fVarying = ext > 1;
 
124
    TqInt i;
 
125
    CqBitVector& RS = m_pEnv->RunningState();
 
126
    for ( i = 0; i < ext; i++ )
 
127
    {
 
128
        if(!fVarying || RS.Value( i ))
 
129
            pV->SetValueFromVariable( Val, i );
 
130
    }
 
131
    RELEASE( Val );
 
132
}
 
133
 
 
134
void CqShaderVM::SO_ipop()
 
135
{
 
136
    AUTOFUNC;
 
137
    UsProgramElement& el = ReadNext();
 
138
    IqShaderData* pV = GetVar( el.m_iVariable );
 
139
    CqShaderVariableArray* pVA = static_cast<CqShaderVariableArray*>( pV );
 
140
    if ( pV->ArrayLength() == 0 )
 
141
    {
 
142
        // Report error.
 
143
        std::cerr << critical << "Attempt to index a non array variable" << std::endl;
 
144
        return ;
 
145
    }
 
146
    POPV( A );
 
147
    POPV( Val );
 
148
    //TqInt ext=__fVarying?m_pEnv->GridSize():1;
 
149
    TqUint ext = MAX( m_pEnv->GridSize(), pV->Size() );
 
150
    TqBool fVarying = ext > 1;
 
151
    TqInt i;
 
152
    CqBitVector& RS = m_pEnv->RunningState();
 
153
    for ( i = 0; i < ext; i++ )
 
154
    {
 
155
        if ( !fVarying || RS.Value( i ) )
 
156
        {
 
157
            TqFloat fIndex;
 
158
            A->GetFloat( fIndex, i );
 
159
            TqInt index = static_cast<unsigned int>( fIndex );
 
160
            ( *pVA ) [ index ] ->SetValueFromVariable( Val, i );
 
161
        }
 
162
    }
 
163
    RELEASE( Val );
 
164
    RELEASE( A );
 
165
}
 
166
 
 
167
void CqShaderVM::SO_mergef()
 
168
{
 
169
    // Get the current state from the current stack entry
 
170
    AUTOFUNC;
 
171
    POPV( A );  // Relational result
 
172
    POPV( F );  // False statement
 
173
    POPV( T );  // True statement
 
174
    RESULT(type_float, class_varying);
 
175
    TqInt i;
 
176
    TqInt ext = m_pEnv->GridSize();
 
177
    for ( i = 0; i < ext; i++ )
 
178
    {
 
179
        TqBool _aq_A;
 
180
        TqFloat _aq_T, _aq_F;
 
181
        A->GetBool( _aq_A, i );
 
182
        T->GetFloat( _aq_T, i );
 
183
        F->GetFloat( _aq_F, i );
 
184
        if ( _aq_A ) pResult->SetValue( _aq_T, i );
 
185
        else    pResult->SetValue( _aq_F, i );
 
186
    }
 
187
    Push( pResult );
 
188
    RELEASE( T );
 
189
    RELEASE( F );
 
190
    RELEASE( A );
 
191
}
 
192
 
 
193
void CqShaderVM::SO_merges()
 
194
{
 
195
    // Get the current state from the current stack entry
 
196
    AUTOFUNC;
 
197
    POPV( A );  // Relational result
 
198
    POPV( F );  // False statement
 
199
    POPV( T );  // True statement
 
200
    RESULT(type_string, class_varying);
 
201
    TqInt i;
 
202
    TqInt ext = m_pEnv->GridSize();
 
203
    for ( i = 0; i < ext; i++ )
 
204
    {
 
205
        TqBool _aq_A;
 
206
        CqString _aq_T, _aq_F;
 
207
        A->GetBool( _aq_A, i );
 
208
        T->GetString( _aq_T, i );
 
209
        F->GetString( _aq_F, i );
 
210
        if ( _aq_A ) pResult->SetValue( _aq_T, i );
 
211
        else    pResult->SetValue( _aq_F, i );
 
212
    }
 
213
    Push( pResult );
 
214
    RELEASE( T );
 
215
    RELEASE( F );
 
216
    RELEASE( A );
 
217
}
 
218
 
 
219
void CqShaderVM::SO_mergep()
 
220
{
 
221
    // Get the current state from the current stack entry
 
222
    AUTOFUNC;
 
223
    POPV( A );  // Relational result
 
224
    POPV( F );  // False statement
 
225
    POPV( T );  // True statement
 
226
    RESULT(type_point, class_varying);
 
227
    TqInt i;
 
228
    TqInt ext = m_pEnv->GridSize();
 
229
    for ( i = 0; i < ext; i++ )
 
230
    {
 
231
        TqBool _aq_A;
 
232
        CqVector3D _aq_T, _aq_F;
 
233
        A->GetBool( _aq_A, i );
 
234
        T->GetPoint( _aq_T, i );
 
235
        F->GetPoint( _aq_F, i );
 
236
        if ( _aq_A ) pResult->SetValue( _aq_T, i );
 
237
        else    pResult->SetValue( _aq_F, i );
 
238
    }
 
239
    Push( pResult );
 
240
    RELEASE( T );
 
241
    RELEASE( F );
 
242
    RELEASE( A );
 
243
}
 
244
 
 
245
void CqShaderVM::SO_mergec()
 
246
{
 
247
    // Get the current state from the current stack entry
 
248
    AUTOFUNC;
 
249
    POPV( A );  // Relational result
 
250
    POPV( F );  // False statement
 
251
    POPV( T );  // True statement
 
252
    RESULT(type_color, class_varying);
 
253
    TqInt i;
 
254
    TqInt ext = m_pEnv->GridSize();
 
255
    for ( i = 0; i < ext; i++ )
 
256
    {
 
257
        TqBool _aq_A;
 
258
        CqColor _aq_T, _aq_F;
 
259
        A->GetBool( _aq_A, i );
 
260
        T->GetColor( _aq_T, i );
 
261
        F->GetColor( _aq_F, i );
 
262
        if ( _aq_A ) pResult->SetValue( _aq_T, i );
 
263
        else    pResult->SetValue( _aq_F, i );
 
264
    }
 
265
    Push( pResult );
 
266
    RELEASE( T );
 
267
    RELEASE( F );
 
268
    RELEASE( A );
 
269
}
 
270
 
 
271
void CqShaderVM::SO_setfc()
 
272
{
 
273
    AUTOFUNC;
 
274
    POPV( A );
 
275
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
276
    OpCAST_FC( A, pResult, m_pEnv->RunningState() );
 
277
    Push( pResult );
 
278
    RELEASE( A );
 
279
}
 
280
 
 
281
void CqShaderVM::SO_setfp()
 
282
{
 
283
    AUTOFUNC;
 
284
    POPV( A );
 
285
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
286
    OpCAST_FP( A, pResult, m_pEnv->RunningState() );
 
287
    Push( pResult );
 
288
    RELEASE( A );
 
289
}
 
290
 
 
291
 
 
292
void CqShaderVM::SO_setfm()
 
293
{
 
294
    AUTOFUNC;
 
295
    POPV( A );
 
296
    RESULT(type_matrix, __fVarying?class_varying:class_uniform);
 
297
    OpCAST_FM( A, pResult, m_pEnv->RunningState() );
 
298
    Push( pResult );
 
299
    RELEASE( A );
 
300
}
 
301
 
 
302
void CqShaderVM::SO_settc()
 
303
{
 
304
    AUTOFUNC;
 
305
    POPV( A );
 
306
    POPV( B );
 
307
    POPV( C );
 
308
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
309
    OpTRIPLE_C( pResult, A, B, C, m_pEnv->RunningState() );
 
310
    Push( pResult );
 
311
    RELEASE( C );
 
312
    RELEASE( B );
 
313
    RELEASE( A );
 
314
}
 
315
 
 
316
void CqShaderVM::SO_settp()
 
317
{
 
318
    AUTOFUNC;
 
319
    POPV( A );
 
320
    POPV( B );
 
321
    POPV( C );
 
322
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
323
    OpTRIPLE_P( pResult, A, B, C, m_pEnv->RunningState() );
 
324
    Push( pResult );
 
325
    RELEASE( C );
 
326
    RELEASE( B );
 
327
    RELEASE( A );
 
328
}
 
329
 
 
330
void CqShaderVM::SO_setpc()
 
331
{
 
332
    AUTOFUNC;
 
333
    POPV( A );
 
334
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
335
    OpCAST_PC( A, pResult, m_pEnv->RunningState() );
 
336
    Push( pResult );
 
337
    RELEASE( A );
 
338
}
 
339
 
 
340
void CqShaderVM::SO_setcp()
 
341
{
 
342
    AUTOFUNC;
 
343
    POPV( A );
 
344
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
345
    OpCAST_CP( A, pResult, m_pEnv->RunningState() );
 
346
    Push( pResult );
 
347
    RELEASE( A );
 
348
}
 
349
 
 
350
void CqShaderVM::SO_setwm()
 
351
{
 
352
    AUTOFUNC;
 
353
    POPV( A );
 
354
    POPV( B );
 
355
    POPV( C );
 
356
    POPV( D );
 
357
    POPV( E );
 
358
    POPV( F );
 
359
    POPV( G );
 
360
    POPV( H );
 
361
    POPV( I );
 
362
    POPV( J );
 
363
    POPV( K );
 
364
    POPV( L );
 
365
    POPV( M );
 
366
    POPV( N );
 
367
    POPV( O );
 
368
    POPV( P );
 
369
    RESULT(type_matrix, __fVarying?class_varying:class_uniform);
 
370
    OpHEXTUPLE_M( pResult, P, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A, m_pEnv->RunningState() );
 
371
    Push( pResult );
 
372
    RELEASE( P );
 
373
    RELEASE( O );
 
374
    RELEASE( N );
 
375
    RELEASE( M );
 
376
    RELEASE( L );
 
377
    RELEASE( K );
 
378
    RELEASE( J );
 
379
    RELEASE( I );
 
380
    RELEASE( H );
 
381
    RELEASE( G );
 
382
    RELEASE( F );
 
383
    RELEASE( E );
 
384
    RELEASE( D );
 
385
    RELEASE( C );
 
386
    RELEASE( B );
 
387
    RELEASE( A );
 
388
}
 
389
 
 
390
void CqShaderVM::SO_RS_PUSH()
 
391
{
 
392
    m_pEnv->PushState();
 
393
}
 
394
 
 
395
void CqShaderVM::SO_RS_POP()
 
396
{
 
397
    m_pEnv->PopState();
 
398
}
 
399
 
 
400
void CqShaderVM::SO_RS_GET()
 
401
{
 
402
    m_pEnv->GetCurrentState();
 
403
}
 
404
 
 
405
void CqShaderVM::SO_RS_INVERSE()
 
406
{
 
407
    m_pEnv->InvertRunningState();
 
408
}
 
409
 
 
410
void CqShaderVM::SO_S_CLEAR()
 
411
{
 
412
    m_pEnv->ClearCurrentState();
 
413
}
 
414
 
 
415
void CqShaderVM::SO_S_GET()
 
416
{
 
417
    // Get the current state from the current stack entry
 
418
    AUTOFUNC;
 
419
    POPV( A );
 
420
    TqInt i;
 
421
    CqBitVector& RS = m_pEnv->RunningState();
 
422
    TqInt ext = m_pEnv->GridSize();
 
423
    for ( i = 0; i < ext; i++ )
 
424
    {
 
425
        if ( RS.Value( i ) )
 
426
        {
 
427
            TqBool _aq_A;
 
428
            A->GetBool( _aq_A, i );
 
429
            m_pEnv->CurrentState().SetValue( i, _aq_A );
 
430
        }
 
431
    }
 
432
    RELEASE( A );
 
433
}
 
434
 
 
435
void CqShaderVM::SO_RS_JZ()
 
436
{
 
437
    SqLabel lab = ReadNext().m_Label;
 
438
    if ( m_pEnv->RunningState().Count() == 0 )
 
439
    {
 
440
        m_PO = lab.m_Offset;
 
441
        m_PC = lab.m_pAddress;
 
442
    }
 
443
}
 
444
 
 
445
void CqShaderVM::SO_RS_JNZ()
 
446
{
 
447
    SqLabel lab = ReadNext().m_Label;
 
448
    if ( m_pEnv->RunningState().Count() == m_pEnv->RunningState().Size() )
 
449
    {
 
450
        m_PO = lab.m_Offset;
 
451
        m_PC = lab.m_pAddress;
 
452
    }
 
453
}
 
454
 
 
455
void CqShaderVM::SO_S_JZ()
 
456
{
 
457
    SqLabel lab = ReadNext().m_Label;
 
458
    if ( m_pEnv->CurrentState().Count() == 0 )
 
459
    {
 
460
        m_PO = lab.m_Offset;
 
461
        m_PC = lab.m_pAddress;
 
462
    }
 
463
}
 
464
 
 
465
void CqShaderVM::SO_S_JNZ()
 
466
{
 
467
    SqLabel lab = ReadNext().m_Label;
 
468
    if ( m_pEnv->CurrentState().Count() == m_pEnv->RunningState().Size() )
 
469
    {
 
470
        m_PO = lab.m_Offset;
 
471
        m_PC = lab.m_pAddress;
 
472
    }
 
473
}
 
474
 
 
475
void CqShaderVM::SO_jnz()
 
476
{
 
477
    SqLabel lab = ReadNext().m_Label;
 
478
    AUTOFUNC;
 
479
    IqShaderData* f = POP.m_Data;
 
480
    TqInt __iGrid = 0;
 
481
    do
 
482
    {
 
483
        if ( !__fVarying || m_pEnv->RunningState().Value( __iGrid ) )
 
484
        {
 
485
            TqBool _f;
 
486
            f->GetBool( _f, __iGrid );
 
487
            if ( !_f ) return ;
 
488
        }
 
489
    }
 
490
    while ( ++__iGrid < m_pEnv->GridSize() );
 
491
    m_PO = lab.m_Offset;
 
492
    m_PC = lab.m_pAddress;
 
493
}
 
494
 
 
495
void CqShaderVM::SO_jz()
 
496
{
 
497
    SqLabel lab = ReadNext().m_Label;
 
498
    AUTOFUNC;
 
499
    IqShaderData* f = POP.m_Data;
 
500
    TqInt __iGrid = 0;
 
501
    do
 
502
    {
 
503
        if ( !__fVarying || m_pEnv->RunningState().Value( __iGrid ) )
 
504
        {
 
505
            TqBool _f;
 
506
            f->GetBool( _f, __iGrid );
 
507
            if ( _f ) return ;
 
508
        }
 
509
    }
 
510
    while ( ++__iGrid < m_pEnv->GridSize() );
 
511
    m_PO = lab.m_Offset;
 
512
    m_PC = lab.m_pAddress;
 
513
}
 
514
 
 
515
void CqShaderVM::SO_jmp()
 
516
{
 
517
    SqLabel lab = ReadNext().m_Label;
 
518
    m_PO = lab.m_Offset;
 
519
    m_PC = lab.m_pAddress;
 
520
}
 
521
 
 
522
void CqShaderVM::SO_lsff()
 
523
{
 
524
    AUTOFUNC;
 
525
    POPV( A );
 
526
    POPV( B );
 
527
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
528
    OpLSS_FF( A, B, pResult, m_pEnv->RunningState() );
 
529
    Push( pResult );
 
530
    RELEASE( B );
 
531
    RELEASE( A );
 
532
}
 
533
 
 
534
void CqShaderVM::SO_lspp()
 
535
{
 
536
    AUTOFUNC;
 
537
    POPV( A );
 
538
    POPV( B );
 
539
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
540
    OpLSS_PP( A, B, pResult, m_pEnv->RunningState() );
 
541
    Push( pResult );
 
542
    RELEASE( B );
 
543
    RELEASE( A );
 
544
}
 
545
 
 
546
void CqShaderVM::SO_lscc()
 
547
{
 
548
    AUTOFUNC;
 
549
    POPV( A );
 
550
    POPV( B );
 
551
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
552
    OpLSS_CC( A, B, pResult, m_pEnv->RunningState() );
 
553
    Push( pResult );
 
554
    RELEASE( B );
 
555
    RELEASE( A );
 
556
}
 
557
 
 
558
void CqShaderVM::SO_gtff()
 
559
{
 
560
    AUTOFUNC;
 
561
    POPV( A );
 
562
    POPV( B );
 
563
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
564
    OpGRT_FF( A, B, pResult, m_pEnv->RunningState() );
 
565
    Push( pResult );
 
566
    RELEASE( B );
 
567
    RELEASE( A );
 
568
}
 
569
 
 
570
void CqShaderVM::SO_gtpp()
 
571
{
 
572
    AUTOFUNC;
 
573
    POPV( A );
 
574
    POPV( B );
 
575
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
576
    OpGRT_PP( A, B, pResult, m_pEnv->RunningState() );
 
577
    Push( pResult );
 
578
    RELEASE( B );
 
579
    RELEASE( A );
 
580
}
 
581
 
 
582
void CqShaderVM::SO_gtcc()
 
583
{
 
584
    AUTOFUNC;
 
585
    POPV( A );
 
586
    POPV( B );
 
587
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
588
    OpGRT_CC( A, B, pResult, m_pEnv->RunningState() );
 
589
    Push( pResult );
 
590
    RELEASE( B );
 
591
    RELEASE( A );
 
592
}
 
593
 
 
594
void CqShaderVM::SO_geff()
 
595
{
 
596
    AUTOFUNC;
 
597
    POPV( A );
 
598
    POPV( B );
 
599
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
600
    OpGE_FF( A, B, pResult, m_pEnv->RunningState() );
 
601
    Push( pResult );
 
602
    RELEASE( B );
 
603
    RELEASE( A );
 
604
}
 
605
 
 
606
void CqShaderVM::SO_gepp()
 
607
{
 
608
    AUTOFUNC;
 
609
    POPV( A );
 
610
    POPV( B );
 
611
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
612
    OpGE_PP( A, B, pResult, m_pEnv->RunningState() );
 
613
    Push( pResult );
 
614
    RELEASE( B );
 
615
    RELEASE( A );
 
616
}
 
617
 
 
618
void CqShaderVM::SO_gecc()
 
619
{
 
620
    AUTOFUNC;
 
621
    POPV( A );
 
622
    POPV( B );
 
623
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
624
    OpGE_CC( A, B, pResult, m_pEnv->RunningState() );
 
625
    Push( pResult );
 
626
    RELEASE( B );
 
627
    RELEASE( A );
 
628
}
 
629
 
 
630
void CqShaderVM::SO_leff()
 
631
{
 
632
    AUTOFUNC;
 
633
    POPV( A );
 
634
    POPV( B );
 
635
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
636
    OpLE_FF( A, B, pResult, m_pEnv->RunningState() );
 
637
    Push( pResult );
 
638
    RELEASE( B );
 
639
    RELEASE( A );
 
640
}
 
641
 
 
642
void CqShaderVM::SO_lepp()
 
643
{
 
644
    AUTOFUNC;
 
645
    POPV( A );
 
646
    POPV( B );
 
647
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
648
    OpLE_PP( A, B, pResult, m_pEnv->RunningState() );
 
649
    Push( pResult );
 
650
    RELEASE( B );
 
651
    RELEASE( A );
 
652
}
 
653
 
 
654
void CqShaderVM::SO_lecc()
 
655
{
 
656
    AUTOFUNC;
 
657
    POPV( A );
 
658
    POPV( B );
 
659
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
660
    OpLE_CC( A, B, pResult, m_pEnv->RunningState() );
 
661
    Push( pResult );
 
662
    RELEASE( B );
 
663
    RELEASE( A );
 
664
}
 
665
 
 
666
void CqShaderVM::SO_eqff()
 
667
{
 
668
    AUTOFUNC;
 
669
    POPV( A );
 
670
    POPV( B );
 
671
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
672
    OpEQ_FF( A, B, pResult, m_pEnv->RunningState() );
 
673
    Push( pResult );
 
674
    RELEASE( B );
 
675
    RELEASE( A );
 
676
}
 
677
 
 
678
void CqShaderVM::SO_eqpp()
 
679
{
 
680
    AUTOFUNC;
 
681
    POPV( A );
 
682
    POPV( B );
 
683
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
684
    OpEQ_PP( A, B, pResult, m_pEnv->RunningState() );
 
685
    Push( pResult );
 
686
    RELEASE( B );
 
687
    RELEASE( A );
 
688
}
 
689
 
 
690
void CqShaderVM::SO_eqcc()
 
691
{
 
692
    AUTOFUNC;
 
693
    POPV( A );
 
694
    POPV( B );
 
695
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
696
    OpEQ_CC( A, B, pResult, m_pEnv->RunningState() );
 
697
    Push( pResult );
 
698
    RELEASE( B );
 
699
    RELEASE( A );
 
700
}
 
701
 
 
702
void CqShaderVM::SO_eqss()
 
703
{
 
704
    AUTOFUNC;
 
705
    POPV( A );
 
706
    POPV( B );
 
707
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
708
    OpEQ_SS( A, B, pResult, m_pEnv->RunningState() );
 
709
    Push( pResult );
 
710
    RELEASE( B );
 
711
    RELEASE( A );
 
712
}
 
713
 
 
714
void CqShaderVM::SO_neff()
 
715
{
 
716
    AUTOFUNC;
 
717
    POPV( A );
 
718
    POPV( B );
 
719
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
720
    OpNE_FF( A, B, pResult, m_pEnv->RunningState() );
 
721
    Push( pResult );
 
722
    RELEASE( B );
 
723
    RELEASE( A );
 
724
}
 
725
 
 
726
void CqShaderVM::SO_nepp()
 
727
{
 
728
    AUTOFUNC;
 
729
    POPV( A );
 
730
    POPV( B );
 
731
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
732
    OpNE_PP( A, B, pResult, m_pEnv->RunningState() );
 
733
    Push( pResult );
 
734
    RELEASE( B );
 
735
    RELEASE( A );
 
736
}
 
737
 
 
738
void CqShaderVM::SO_necc()
 
739
{
 
740
    AUTOFUNC;
 
741
    POPV( A );
 
742
    POPV( B );
 
743
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
744
    OpNE_CC( A, B, pResult, m_pEnv->RunningState() );
 
745
    Push( pResult );
 
746
    RELEASE( B );
 
747
    RELEASE( A );
 
748
}
 
749
 
 
750
void CqShaderVM::SO_ness()
 
751
{
 
752
    AUTOFUNC;
 
753
    POPV( A );
 
754
    POPV( B );
 
755
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
756
    OpNE_SS( A, B, pResult, m_pEnv->RunningState() );
 
757
    Push( pResult );
 
758
    RELEASE( B );
 
759
    RELEASE( A );
 
760
}
 
761
 
 
762
void CqShaderVM::SO_mulff()
 
763
{
 
764
    AUTOFUNC;
 
765
    POPV( A );
 
766
    POPV( B );
 
767
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
768
    OpMUL_FF( A, B, pResult, m_pEnv->RunningState() );
 
769
    Push( pResult );
 
770
    RELEASE( B );
 
771
    RELEASE( A );
 
772
}
 
773
 
 
774
void CqShaderVM::SO_divff()
 
775
{
 
776
    AUTOFUNC;
 
777
    POPV( A );
 
778
    POPV( B );
 
779
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
780
    OpDIV_FF( A, B, pResult, m_pEnv->RunningState() );
 
781
    Push( pResult );
 
782
    RELEASE( B );
 
783
    RELEASE( A );
 
784
}
 
785
 
 
786
void CqShaderVM::SO_addff()
 
787
{
 
788
    AUTOFUNC;
 
789
    POPV( A );
 
790
    POPV( B );
 
791
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
792
    OpADD_FF( A, B, pResult, m_pEnv->RunningState() );
 
793
    Push( pResult );
 
794
    RELEASE( B );
 
795
    RELEASE( A );
 
796
}
 
797
 
 
798
void CqShaderVM::SO_subff()
 
799
{
 
800
    AUTOFUNC;
 
801
    POPV( A );
 
802
    POPV( B );
 
803
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
804
    OpSUB_FF( A, B, pResult, m_pEnv->RunningState() );
 
805
    Push( pResult );
 
806
    RELEASE( B );
 
807
    RELEASE( A );
 
808
}
 
809
 
 
810
void CqShaderVM::SO_negf()
 
811
{
 
812
    AUTOFUNC;
 
813
    POPV( A );
 
814
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
815
    OpNEG_F( A, pResult, m_pEnv->RunningState() );
 
816
    Push( pResult );
 
817
    RELEASE( A );
 
818
}
 
819
 
 
820
void CqShaderVM::SO_mulpp()
 
821
{
 
822
    AUTOFUNC;
 
823
    POPV( A );
 
824
    POPV( B );
 
825
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
826
    OpMULV( A, B, pResult, m_pEnv->RunningState() );
 
827
    Push( pResult );
 
828
    RELEASE( B );
 
829
    RELEASE( A );
 
830
}
 
831
 
 
832
void CqShaderVM::SO_divpp()
 
833
{
 
834
    AUTOFUNC;
 
835
    POPV( A );
 
836
    POPV( B );
 
837
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
838
    OpDIV_PP( A, B, pResult, m_pEnv->RunningState() );
 
839
    Push( pResult );
 
840
    RELEASE( B );
 
841
    RELEASE( A );
 
842
}
 
843
 
 
844
void CqShaderVM::SO_addpp()
 
845
{
 
846
    AUTOFUNC;
 
847
    POPV( A );
 
848
    POPV( B );
 
849
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
850
    OpADD_PP( A, B, pResult, m_pEnv->RunningState() );
 
851
    Push( pResult );
 
852
    RELEASE( B );
 
853
    RELEASE( A );
 
854
}
 
855
 
 
856
void CqShaderVM::SO_subpp()
 
857
{
 
858
    AUTOFUNC;
 
859
    POPV( A );
 
860
    POPV( B );
 
861
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
862
    OpSUB_PP( A, B, pResult, m_pEnv->RunningState() );
 
863
    Push( pResult );
 
864
    RELEASE( B );
 
865
    RELEASE( A );
 
866
}
 
867
 
 
868
void CqShaderVM::SO_crspp()
 
869
{
 
870
    AUTOFUNC;
 
871
    POPV( A );
 
872
    POPV( B );
 
873
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
874
    OpCRS_PP( A, B, pResult, m_pEnv->RunningState() );
 
875
    Push( pResult );
 
876
    RELEASE( B );
 
877
    RELEASE( A );
 
878
}
 
879
 
 
880
void CqShaderVM::SO_dotpp()
 
881
{
 
882
    AUTOFUNC;
 
883
    POPV( A );
 
884
    POPV( B );
 
885
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
886
    OpDOT_PP( A, B, pResult, m_pEnv->RunningState() );
 
887
    Push( pResult );
 
888
    RELEASE( B );
 
889
    RELEASE( A );
 
890
}
 
891
 
 
892
void CqShaderVM::SO_negp()
 
893
{
 
894
    AUTOFUNC;
 
895
    POPV( A );
 
896
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
897
    OpNEG_P( A, pResult, m_pEnv->RunningState() );
 
898
    Push( pResult );
 
899
    RELEASE( A );
 
900
}
 
901
 
 
902
void CqShaderVM::SO_mulcc()
 
903
{
 
904
    AUTOFUNC;
 
905
    POPV( A );
 
906
    POPV( B );
 
907
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
908
    OpMUL_CC( A, B, pResult, m_pEnv->RunningState() );
 
909
    Push( pResult );
 
910
    RELEASE( B );
 
911
    RELEASE( A );
 
912
}
 
913
 
 
914
void CqShaderVM::SO_divcc()
 
915
{
 
916
    AUTOFUNC;
 
917
    POPV( A );
 
918
    POPV( B );
 
919
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
920
    OpDIV_CC( A, B, pResult, m_pEnv->RunningState() );
 
921
    Push( pResult );
 
922
    RELEASE( B );
 
923
    RELEASE( A );
 
924
}
 
925
 
 
926
void CqShaderVM::SO_addcc()
 
927
{
 
928
    AUTOFUNC;
 
929
    POPV( A );
 
930
    POPV( B );
 
931
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
932
    OpADD_CC( A, B, pResult, m_pEnv->RunningState() );
 
933
    Push( pResult );
 
934
    RELEASE( B );
 
935
    RELEASE( A );
 
936
}
 
937
 
 
938
void CqShaderVM::SO_subcc()
 
939
{
 
940
    AUTOFUNC;
 
941
    POPV( A );
 
942
    POPV( B );
 
943
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
944
    OpSUB_CC( A, B, pResult, m_pEnv->RunningState() );
 
945
    Push( pResult );
 
946
    RELEASE( B );
 
947
    RELEASE( A );
 
948
}
 
949
 
 
950
void CqShaderVM::SO_crscc()
 
951
{
 
952
    AUTOFUNC;
 
953
    POPV( A );
 
954
    POPV( B );
 
955
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
956
    OpCRS_CC( A, B, pResult, m_pEnv->RunningState() );
 
957
    Push( pResult );
 
958
    RELEASE( B );
 
959
    RELEASE( A );
 
960
}
 
961
 
 
962
void CqShaderVM::SO_dotcc()
 
963
{
 
964
    AUTOFUNC;
 
965
    POPV( A );
 
966
    POPV( B );
 
967
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
968
    OpDOT_CC( A, B, pResult, m_pEnv->RunningState() );
 
969
    Push( pResult );
 
970
    RELEASE( B );
 
971
    RELEASE( A );
 
972
}
 
973
 
 
974
void CqShaderVM::SO_negc()
 
975
{
 
976
    AUTOFUNC;
 
977
    POPV( A );
 
978
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
979
    OpNEG_C( A, pResult, m_pEnv->RunningState() );
 
980
    Push( pResult );
 
981
    RELEASE( A );
 
982
}
 
983
 
 
984
void CqShaderVM::SO_mulfp()
 
985
{
 
986
    AUTOFUNC;
 
987
    POPV( A );
 
988
    POPV( B );
 
989
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
990
    OpMUL_FP( A, B, pResult, m_pEnv->RunningState() );
 
991
    Push( pResult );
 
992
    RELEASE( B );
 
993
    RELEASE( A );
 
994
}
 
995
 
 
996
void CqShaderVM::SO_divfp()
 
997
{
 
998
    AUTOFUNC;
 
999
    POPV( A );
 
1000
    POPV( B );
 
1001
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
1002
    OpDIV_FP( A, B, pResult, m_pEnv->RunningState() );
 
1003
    Push( pResult );
 
1004
    RELEASE( B );
 
1005
    RELEASE( A );
 
1006
}
 
1007
 
 
1008
void CqShaderVM::SO_addfp()
 
1009
{
 
1010
    AUTOFUNC;
 
1011
    POPV( A );
 
1012
    POPV( B );
 
1013
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
1014
    OpADD_FP( A, B, pResult, m_pEnv->RunningState() );
 
1015
    Push( pResult );
 
1016
    RELEASE( B );
 
1017
    RELEASE( A );
 
1018
}
 
1019
 
 
1020
void CqShaderVM::SO_subfp()
 
1021
{
 
1022
    AUTOFUNC;
 
1023
    POPV( A );
 
1024
    POPV( B );
 
1025
    RESULT(type_point, __fVarying?class_varying:class_uniform);
 
1026
    OpSUB_FP( A, B, pResult, m_pEnv->RunningState() );
 
1027
    Push( pResult );
 
1028
    RELEASE( B );
 
1029
    RELEASE( A );
 
1030
}
 
1031
 
 
1032
void CqShaderVM::SO_mulfc()
 
1033
{
 
1034
    AUTOFUNC;
 
1035
    POPV( A );
 
1036
    POPV( B );
 
1037
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
1038
    OpMUL_FC( A, B, pResult, m_pEnv->RunningState() );
 
1039
    Push( pResult );
 
1040
    RELEASE( B );
 
1041
    RELEASE( A );
 
1042
}
 
1043
 
 
1044
void CqShaderVM::SO_divfc()
 
1045
{
 
1046
    AUTOFUNC;
 
1047
    POPV( A );
 
1048
    POPV( B );
 
1049
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
1050
    OpDIV_FC( A, B, pResult, m_pEnv->RunningState() );
 
1051
    Push( pResult );
 
1052
    RELEASE( B );
 
1053
    RELEASE( A );
 
1054
}
 
1055
 
 
1056
void CqShaderVM::SO_addfc()
 
1057
{
 
1058
    AUTOFUNC;
 
1059
    POPV( A );
 
1060
    POPV( B );
 
1061
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
1062
    OpADD_FC( A, B, pResult, m_pEnv->RunningState() );
 
1063
    Push( pResult );
 
1064
    RELEASE( B );
 
1065
    RELEASE( A );
 
1066
}
 
1067
 
 
1068
void CqShaderVM::SO_subfc()
 
1069
{
 
1070
    AUTOFUNC;
 
1071
    POPV( A );
 
1072
    POPV( B );
 
1073
    RESULT(type_color, __fVarying?class_varying:class_uniform);
 
1074
    OpSUB_FC( A, B, pResult, m_pEnv->RunningState() );
 
1075
    Push( pResult );
 
1076
    RELEASE( B );
 
1077
    RELEASE( A );
 
1078
}
 
1079
 
 
1080
void CqShaderVM::SO_mulmm()
 
1081
{
 
1082
    AUTOFUNC;
 
1083
    RESULT(type_float, class_uniform);
 
1084
    pResult->SetFloat( 0.0f );
 
1085
    Push( pResult );    /* TODO: Implement matrices in the VM*/
 
1086
}
 
1087
 
 
1088
void CqShaderVM::SO_divmm()
 
1089
{
 
1090
    AUTOFUNC;
 
1091
    RESULT(type_float, class_uniform);
 
1092
    pResult->SetFloat( 0.0f );
 
1093
    Push( pResult );    /* TODO: Implement matrices in the VM*/
 
1094
}
 
1095
 
 
1096
void CqShaderVM::SO_land()
 
1097
{
 
1098
    AUTOFUNC;
 
1099
    POPV( A );
 
1100
    POPV( B );
 
1101
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
1102
    OpLAND_B( A, B, pResult, m_pEnv->RunningState() );
 
1103
    Push( pResult );
 
1104
    RELEASE( B );
 
1105
    RELEASE( A );
 
1106
}
 
1107
 
 
1108
void CqShaderVM::SO_lor()
 
1109
{
 
1110
    AUTOFUNC;
 
1111
    POPV( A );
 
1112
    POPV( B );
 
1113
    RESULT(type_float, __fVarying?class_varying:class_uniform);
 
1114
    OpLOR_B( A, B, pResult, m_pEnv->RunningState() );
 
1115
    Push( pResult );
 
1116
    RELEASE( B );
 
1117
    RELEASE( A );
 
1118
}
 
1119
 
 
1120
void CqShaderVM::SO_radians()
 
1121
{
 
1122
    AUTOFUNC;
 
1123
    FUNC1( type_float, m_pEnv->SO_radians );
 
1124
}
 
1125
 
 
1126
void CqShaderVM::SO_degrees()
 
1127
{
 
1128
    AUTOFUNC;
 
1129
    FUNC1( type_float, m_pEnv->SO_degrees );
 
1130
}
 
1131
 
 
1132
void CqShaderVM::SO_sin()
 
1133
{
 
1134
    AUTOFUNC;
 
1135
    FUNC1( type_float, m_pEnv->SO_sin );
 
1136
}
 
1137
 
 
1138
void CqShaderVM::SO_asin()
 
1139
{
 
1140
    AUTOFUNC;
 
1141
    FUNC1( type_float, m_pEnv->SO_asin );
 
1142
}
 
1143
 
 
1144
void CqShaderVM::SO_cos()
 
1145
{
 
1146
    AUTOFUNC;
 
1147
    FUNC1( type_float, m_pEnv->SO_cos );
 
1148
}
 
1149
 
 
1150
void CqShaderVM::SO_acos()
 
1151
{
 
1152
    AUTOFUNC;
 
1153
    FUNC1( type_float, m_pEnv->SO_acos );
 
1154
}
 
1155
 
 
1156
void CqShaderVM::SO_tan()
 
1157
{
 
1158
    AUTOFUNC;
 
1159
    FUNC1( type_float, m_pEnv->SO_tan );
 
1160
}
 
1161
 
 
1162
void CqShaderVM::SO_atan()
 
1163
{
 
1164
    AUTOFUNC;
 
1165
    FUNC1( type_float, m_pEnv->SO_atan );
 
1166
}
 
1167
 
 
1168
void CqShaderVM::SO_atan2()
 
1169
{
 
1170
    AUTOFUNC;
 
1171
    FUNC2( type_float, m_pEnv->SO_atan );
 
1172
}
 
1173
 
 
1174
void CqShaderVM::SO_pow()
 
1175
{
 
1176
    AUTOFUNC;
 
1177
    FUNC2( type_float, m_pEnv->SO_pow );
 
1178
}
 
1179
 
 
1180
END_NAMESPACE( Aqsis )
 
1181
//---------------------------------------------------------------------