Changeset 390

Show
Ignore:
Timestamp:
05/17/07 18:27:45 (17 months ago)
Author:
krobillard
Message:

Thune - OpenGL version works in thread_safe branch.

Location:
branches/thune/thread_safe
Files:
18 modified

Legend:

Unmodified
Added
Removed

  • branches/thune/thread_safe/gl/audio.c

    r362 r390  
    166166    } 
    167167 
    168     file = ur_cstring( tos ); 
     168    file = ur_cstring( ut, tos ); 
    169169    if( file ) 
    170170    { 

  • branches/thune/thread_safe/gl/boot.c

    r383 r390  
    3737  "[wid | handler]\n" 
    3838  "[\n" 
    39   "    display.events [\n" 
     39  "    [] display.events [\n" 
    4040  "        dup first wid get dup :handler\n" 
    4141  "        ift (second handler do) drop\n" 

  • branches/thune/thread_safe/gl/draw_list.c

    r383 r390  
    283283   The pen is moved to the end of text. 
    284284*/ 
    285 void gr_drawText( const char* it, const char* end ) 
     285void gr_drawText( UThread* ut, const char* it, const char* end ) 
    286286{ 
    287287    GLfloat x, y; 
    … …  
    328328 
    329329 
    330 void gr_drawTextCell( UThread* ur_thread, UCell* cell ) 
     330void gr_drawTextCell( UThread* ut, UCell* cell ) 
    331331{ 
    332332    char* cpA; 
    333333    char* cpB; 
    334334 
    335     if( ur_stringSlice( cell, &cpA, &cpB ) ) 
    336     { 
    337         gr_drawText( cpA, cpB ); 
     335    if( ur_stringSlice( ut, cell, &cpA, &cpB ) ) 
     336    { 
     337        gr_drawText( ut, cpA, cpB ); 
    338338    } 
    339339    else 
    340340    { 
    341         UString* str; 
    342         str = ur_binPtr( ur_thread->callTempBinN ); 
     341        UString* str = ur_threadTmp( ut ); 
    343342        str->used = 0; 
    344343        ur_toStr( cell, str, 0 ); 
    345         gr_drawText( str->ptr.c, str->ptr.c + str->used ); 
     344        gr_drawText( ut, str->ptr.c, str->ptr.c + str->used ); 
    346345    } 
    347346} 
    … …  
    375374 
    376375 
    377 static void dop_camera( UCell* ctx ) 
     376static void dop_camera( UThread* ut, UCell* ctx ) 
    378377{ 
    379378    double w, h; 
    … …  
    466465 
    467466 
    468 static void dop_light( UThread* ur_thread, UCell* val, int light ) 
     467static void dop_light( UThread* ut, UCell* val, int light ) 
    469468{ 
    470469    if( ur_is(val, UT_LOGIC) ) 
    … …  
    497496 
    498497                    default: 
    499                         val = ur_wordCell( ur_thread, it ); 
     498                        val = ur_wordCell( ut, it ); 
    500499                        if( val ) 
    501500                        { 
    … …  
    532531   Camera must be set up for light before calling shadow-begin. 
    533532*/ 
    534 static void dop_shadow_begin( /*UThread* ur_thread,*/ UCell* fbCell ) 
     533static void dop_shadow_begin( /*UThread* ut,*/ UCell* fbCell ) 
    535534{ 
    536535    // Save matrices for shadow-end. 
    … …  
    604603  Returns pc at last argument or zero if arguments are bad. 
    605604*/ 
    606 static UCell* dop_attrib( UThread* ur_thread, UCell* pc ) 
     605static UCell* dop_attrib( UThread* ut, UCell* pc ) 
    607606{ 
    608607    GrVertexAttribute* attr; 
    … …  
    614613    if( ur_is(pc, UT_SELECT) ) 
    615614    { 
    616         UCell* val = ur_wordCell( ur_thread, pc ); 
     615        UCell* val = ur_wordCell( ut, pc ); 
    617616        if( ! val ) 
    618617            return 0; 
    … …  
    673672   icell is an int array! 
    674673*/ 
    675 static void _drawPrims( UCell* icell, const char* key ) 
     674static void _drawPrims( UThread* ut, UCell* icell, const char* key ) 
    676675{ 
    677676    //GLdouble vec[3]; 
    … …  
    771770#define VAL_WORD_OR_PC \ 
    772771    if( ur_is(pc, UT_WORD) ) { \ 
    773         val = ur_wordCell( ur_thread, pc ); \ 
     772        val = ur_wordCell( ut, pc ); \ 
    774773        if( ! val ) return 0; \ 
    775774    } \ 
    … …  
    779778   Returns zero if an error occurred. 
    780779*/ 
    781 static int _runDrawList( UThread* ur_thread, UCell* val ) 
     780static int _runDrawList( UThread* ut, UCell* val ) 
    782781{ 
    783782    UBlock* blk = ur_blockPtr( val->series.n ); 
    … …  
    811810                        glCallList( ur_dlGL(val) ); 
    812811                    } 
    813                     else if( ! _runDrawList( ur_thread, val ) ) 
     812                    else if( ! _runDrawList( ut, val ) ) 
    814813                        return 0; 
    815814                } 
    … …  
    867866                VAL_WORD_OR_PC 
    868867                if( ur_is(val, UT_CONTEXT) ) 
    869                     dop_camera( val ); 
     868                    dop_camera( ut, val ); 
    870869            } 
    871870                break; 
    … …  
    877876                ++pc; 
    878877                VAL_WORD_OR_PC 
    879                 dop_light( ur_thread, val, GL_LIGHT0 + light ); 
     878                dop_light( ut, val, GL_LIGHT0 + light ); 
    880879            } 
    881880                break; 
    … …  
    946945 
    947946            case DOP_ATTRIB: 
    948                 pc = dop_attrib( ur_thread, pc ); 
     947                pc = dop_attrib( ut, pc ); 
    949948                if( ! pc ) 
    950949                    return 0; 
    … …  
    965964                { 
    966965                    glBegin( _primBegin[ ur_opcode(pc-2) - DOP_POINTS ] ); 
    967                     _drawPrims( pc, ur_atomCStr( ur_atom(pc-1), 0 ) ); 
     966                    _drawPrims( ut, pc, ur_atomCStr( ur_atom(pc-1), 0 ) ); 
    968967                    glEnd(); 
    969968                } 
    … …  
    10471046                    VAL_WORD_OR_PC 
    10481047                } 
    1049                 gr_drawTextCell( ur_thread, val ); 
     1048                gr_drawTextCell( ut, val ); 
    10501049                break; 
    10511050 
    … …  
    10531052                ++pc; 
    10541053                VAL_WORD_OR_PC 
    1055                 loadShader( val ); 
     1054                loadShader( ut, val ); 
    10561055                break; 
    10571056 
    … …  
    10691068                VAL_WORD_OR_PC 
    10701069                if( ur_is(val, UT_FBO) ) 
    1071                     dop_shadow_begin( /*ur_thread,*/ val ); 
     1070                    dop_shadow_begin( /*ut,*/ val ); 
    10721071                break; 
    10731072 
    … …  
    10971096    UCell* res = ur_s_prev(tos); 
    10981097 
    1099     ops = ur_resolveArgPath( UT_WORD, UR_ATOM_DRAW_LIST_OPCODES, UT_NONE );  
     1098    ops = ur_resolvePath( ut, UR_ATOM_DRAW_LIST_OPCODES, UT_NONE );  
    11001099    if( ! ops ) 
    11011100    { 
    … …  
    11061105    if( ur_is(tos, UT_BLOCK) ) 
    11071106    { 
    1108         ur_infuse( ur_thread, ur_block(tos), ops ); 
     1107        ur_infuse( ut, ur_block(tos), ops ); 
    11091108 
    11101109        ur_initType(res, UT_DRAWLIST); 
    … …  
    11171116        int pool; 
    11181117 
    1119         ur_infuse( ur_thread, ur_block(tos), ops ); 
     1118        ur_infuse( ut, ur_block(tos), ops ); 
    11201119 
    11211120        ur_initType(res, UT_DRAWLIST); 
    … …  
    11301129        glNewList( ur_dlGL(res), GL_COMPILE ); 
    11311130 
    1132         if( ! _runDrawList( ur_thread, tos ) ) 
     1131        if( ! _runDrawList( ut, tos ) ) 
    11331132        { 
    11341133            ur_throwErr( UR_ERR_SCRIPT, "runDrawList failed" ); 
    … …  
    11601159            glCallList( ur_dlGL(tos) ); 
    11611160        else 
    1162             _runDrawList( ur_thread, tos ); 
     1161            _runDrawList( ut, tos ); 
    11631162    } 
    11641163    UR_S_DROP; 

  • branches/thune/thread_safe/gl/gx.c

    r382 r390  
    2626#include <string.h> 
    2727#include <glv_keys.h> 
    28 #include "os.h" 
     28#include "env.h" 
    2929#include "glh.h" 
    3030#include "gx.h" 
    … …  
    571571    UCell* res = ur_s_prev( tos ); 
    572572 
    573     if( ur_stringSlice( tos, &cpA, &cpB ) ) 
     573    if( ur_stringSlice( ut, tos, &cpA, &cpB ) ) 
    574574    { 
    575575        if( ur_is( res, UT_FONT ) ) 
    … …  
    589589 
    590590 
    591 // ( -- blk) 
     591// (blk -- blk) 
    592592UR_CALL( uc_display_events ) 
    593593{ 
    594     UIndex blkN; 
    595  
    596     UR_CALL_UNUSED_TOS 
    597  
    598     blkN = ur_holdIndex( ur_thread->env, gxEnv.eventBlkHold ); 
    599     gxEnv.eventBlk = ur_blockPtr( blkN ); 
     594    if( ! ur_is(tos, UT_BLOCK) ) 
     595    { 
     596        ur_throwErr( UR_ERR_DATATYPE, "display.events expected block!" ); 
     597        return; 
     598    } 
     599 
     600    gxEnv.eventBlk = ur_block( tos ); 
    600601    gxEnv.eventBlk->used = 0; 
    601602 
    602603    glv_handleEvents( gView ); 
    603  
    604     UR_S_GROW; 
    605  
    606     ur_initType(UR_TOS, UT_BLOCK); 
    607     ur_setSeries(UR_TOS, blkN, 0); 
    608604} 
    609605 
    … …  
    670666    glGetIntegerv( GL_VIEWPORT, vp ); 
    671667 
    672     ur_makeRaster( ur_s_next(tos), UR_RAST_RGB, vp[2], vp[3], &bin ); 
     668    ur_makeRaster( ut, ur_s_next(tos), UR_RAST_RGB, vp[2], vp[3], &bin ); 
    673669    UR_S_GROW; 
    674670 
    … …  
    14291425#if MAKE_ATOM_HEADER 
    14301426#define FIXED_ATOM(str,len,def) \ 
    1431     printf( "#define %s\t\t%d\n", #def, ur_intern(env,str,len) ); 
     1427    printf( "#define %s\t\t%d\n", #def, ur_intern(str,len) ); 
    14321428#else 
    14331429#ifdef DEBUG 
    1434 #define FIXED_ATOM(str,len,def)     assert( ur_intern(env,str,len) == def ); 
     1430#define FIXED_ATOM(str,len,def)     assert( ur_intern(str,len) == def ); 
    14351431#else 
    1436 #define FIXED_ATOM(str,len,def)     ur_intern(env,str,len); 
     1432#define FIXED_ATOM(str,len,def)     ur_intern(str,len); 
    14371433#endif 
    14381434#endif 
    14391435 
    14401436// Intern commonly used atoms. 
    1441 static void _createFixedAtoms( UrlanEnv* env ) 
     1437static void _createFixedAtoms( UThread* ut ) 
    14421438{ 
    14431439#if MAKE_ATOM_HEADER 
    … …  
    15011497{ 
    15021498    const GLubyte* gstr; 
     1499    UThread* ut = env->threads; 
    15031500 
    15041501#if 0 
    … …  
    15111508    gxEnv.prevMouseY = MOUSE_UNSET; 
    15121509 
    1513     _createFixedAtoms( env ); 
     1510    _createFixedAtoms( ut ); 
    15141511 
    15151512    gxEnv.eventBlk = 0; 
    1516     gxEnv.eventBlkHold = ur_hold( env, UT_BLOCK, ur_makeBlock( 32 ) ); 
    1517  
    1518  
    1519     ur_makeCalls( env, _gxCalls, sizeof(_gxCalls) / sizeof(UCallDef) ); 
    1520  
    1521     { 
    1522         int ok = ur_evalCStr( env->threads, _gxBoot, sizeof(_gxBoot) ); 
     1513 
     1514 
     1515    ur_makeCalls( ut, _gxCalls, sizeof(_gxCalls) / sizeof(UCallDef) ); 
     1516 
     1517    { 
     1518        int ok = ur_evalCStr( ut, _gxBoot, sizeof(_gxBoot) ); 
    15231519        if( ok != UR_EVAL_OK ) 
    15241520            return ok; 
    … …  
    15371533    if( ! gView ) 
    15381534    { 
    1539         ur_throwErr( env->threads, UR_EX_INTERNAL, "glv_create() failed" ); 
     1535        ur_throwErr( ut, UR_EX_INTERNAL, "glv_create() failed" ); 
    15401536        return UR_EVAL_ERROR; 
    15411537    } 
    … …  
    15461542        glv_destroy( gView ); 
    15471543        gView = 0; 
    1548         ur_throwErr( env->threads, UR_EX_INTERNAL, "OpenGL 2.0 required" ); 
     1544        ur_throwErr( ut, UR_EX_INTERNAL, "OpenGL 2.0 required" ); 
    15491545        return UR_EVAL_ERROR; 
    15501546    } 
    … …  
    15651561void gx_shutdown( UrlanEnv* env ) 
    15661562{ 
     1563    (void) env; 
    15671564#if 0 
    15681565    resd_free( &gEnv.resd ); 
    … …  
    15741571 
    15751572    glv_destroy( gView ); 
    1576  
    1577     ur_release( env, gxEnv.eventBlkHold ); 
    15781573} 
    15791574 

  • branches/thune/thread_safe/gl/gx.h

    r383 r390  
    157157    int prevMouseY; 
    158158 
    159     UIndex  eventBlkHold; 
    160159    UBlock* eventBlk; 
    161160 
    … …  
    205204 
    206205 
    207 UIndex ur_makeRaster( UCell*, int format, int w, int h, UBinary** ); 
     206UIndex ur_makeRaster( UThread*, UCell*, int format, int w, int h, UBinary** ); 
    208207 
    209208#define ur_dlGL(c)          ((UCellDrawList*) (c))->glListId 

  • branches/thune/thread_safe/gl/gx.t

    r383 r390  
    8282[wid | handler] 
    8383[ 
    84     display.events [ 
     84    [] display.events [ 
    8585        /* 
    8686        ;Had problem with keeping stack level here: 

  • branches/thune/thread_safe/gl/gx_atoms.h

    r382 r390  
    11// This file is automatically generated - do not edit. 
    22 
    3 #define UR_ATOM_DRAW_LIST_OPCODES               313 
    4 #define UR_ATOM_WIDTH           314 
    5 #define UR_ATOM_HEIGHT          315 
    6 #define UR_ATOM_AREA            316 
    7 #define UR_ATOM_RECT            317 
    8 #define UR_ATOM_RASTER          318 
    9 #define UR_ATOM_TEXTURE         319 
    10 #define UR_ATOM_ELEM            320 
    11 #define UR_ATOM_CLOSE           175 
    12 #define UR_ATOM_FOCUS           321 
    13 #define UR_ATOM_RESIZE          322 
    14 #define UR_ATOM_KEY_DOWN                323 
    15 #define UR_ATOM_KEY_UP          324 
    16 #define UR_ATOM_MOUSE_MOVE              325 
    17 #define UR_ATOM_MOUSE_UP                326 
    18 #define UR_ATOM_MOUSE_DOWN              327 
    19 #define UR_ATOM_MOUSE_WHEEL             328 
    20 #define UR_ATOM_AMBIENT         329 
    21 #define UR_ATOM_DIFFUSE         330 
    22 #define UR_ATOM_SPECULAR                331 
    23 #define UR_ATOM_POS             332 
    24 #define UR_ATOM_SHADER          333 
    25 #define UR_ATOM_VERTEX          334 
    26 #define UR_ATOM_FRAGMENT                335 
    27 #define UR_ATOM_DEFAULT         336 
    28 #define UR_ATOM_RGB             337 
    29 #define UR_ATOM_RGBA            338 
    30 #define UR_ATOM_DEPTH           339 
    31 #define UR_ATOM_CLAMP           340 
    32 #define UR_ATOM_REPEAT          341 
    33 #define UR_ATOM_NEAREST         342 
    34 #define UR_ATOM_LINEAR          343 
    35 #define UR_ATOM_MIN             344 
    36 #define UR_ATOM_MAG             345 
    37 #define UR_ATOM_MIPMAP          346 
    38 #define UR_ATOM_ON              253 
    39 #define UR_ATOM_OFF             255 
    40 #define UR_ATOM_ADD             194 
    41 #define UR_ATOM_BURN            347 
    42 #define UR_ATOM_COLOR           348 
    43 #define UR_ATOM_TRANS           349 
     3#define UR_ATOM_DRAW_LIST_OPCODES               312 
     4#define UR_ATOM_WIDTH           313 
     5#define UR_ATOM_HEIGHT          314 
     6#define UR_ATOM_AREA            315 
     7#define UR_ATOM_RECT            316 
     8#define UR_ATOM_RASTER          317 
     9#define UR_ATOM_TEXTURE         318 
     10#define UR_ATOM_ELEM            319 
     11#define UR_ATOM_CLOSE           174 
     12#define UR_ATOM_FOCUS           320 
     13#define UR_ATOM_RESIZE          321 
     14#define UR_ATOM_KEY_DOWN                322 
     15#define UR_ATOM_KEY_UP          323 
     16#define UR_ATOM_MOUSE_MOVE              324 
     17#define UR_ATOM_MOUSE_UP                325 
     18#define UR_ATOM_MOUSE_DOWN              326 
     19#define UR_ATOM_MOUSE_WHEEL             327 
     20#define UR_ATOM_AMBIENT         328 
     21#define UR_ATOM_DIFFUSE         329 
     22#define UR_ATOM_SPECULAR                330 
     23#define UR_ATOM_POS             331 
     24#define UR_ATOM_SHADER          332 
     25#define UR_ATOM_VERTEX          333 
     26#define UR_ATOM_FRAGMENT                334 
     27#define UR_ATOM_DEFAULT         335 
     28#define UR_ATOM_RGB             336 
     29#define UR_ATOM_RGBA            337 
     30#define UR_ATOM_DEPTH           338 
     31#define UR_ATOM_CLAMP           339 
     32#define UR_ATOM_REPEAT          340 
     33#define UR_ATOM_NEAREST         341 
     34#define UR_ATOM_LINEAR          342 
     35#define UR_ATOM_MIN             343 
     36#define UR_ATOM_MAG             344 
     37#define UR_ATOM_MIPMAP          345 
     38#define UR_ATOM_ON              252 
     39#define UR_ATOM_OFF             254 
     40#define UR_ATOM_ADD             193 
     41#define UR_ATOM_BURN            346 
     42#define UR_ATOM_COLOR           347 
     43#define UR_ATOM_TRANS           348 

  • branches/thune/thread_safe/gl/gx_dt.c

    r360 r390  
    3838 
    3939 
    40 static void toStr_dlist( const UCell* cell, UString* out, int depth ) 
    41 { 
     40static void toStr_dlist( UThread* ut, const UCell* cell, UString* out, 
     41                         int depth ) 
     42{ 
     43    (void) ut; 
    4244    (void) cell; 
    4345    (void) depth; 
    … …  
    7375  \return Binary index and initialied res.  If binp is non-zero, it is set. 
    7476*/ 
    75 UIndex ur_makeRaster( UCell* res, int format, int w, int h, UBinary** binp ) 
     77UIndex ur_makeRaster( UThread* ut, UCell* res, 
     78                      int format, int w, int h, UBinary** binp ) 
    7679{ 
    7780    UIndex binN; 
    … …  
    122125            } 
    123126 
    124             ur_makeRaster( res, format, 
     127            ur_makeRaster( ut, res, format, 
    125128                           tos->coord.elem[0], tos->coord.elem[1], 0 ); 
    126129 
    … …  
    148151 
    149152 
    150 static void toStr_raster( const UCell* cell, UString* out, int depth ) 
     153static void toStr_raster( UThread* ut, const UCell* cell, UString* out, 
     154                          int depth ) 
    151155{ 
    152156    int uformat; 
    … …  
    178182 
    179183 
    180 static int select_raster( UThread* ur_thread, UCell* val, const UCell* sel, 
     184static int select_raster( UThread* ut, UCell* val, const UCell* sel, 
    181185                          UCell* res ) 
    182186{ 
    … …  
    350354                { 
    351355                    case UT_WORD: 
    352                         val = ur_wordCell( ur_thread, it ); 
     356                        val = ur_wordCell( ut, it ); 
    353357                        if( ! val ) 
    354358                            return; 
    … …  
    461465 
    462466 
    463 static void toStr_texture( const UCell* cell, UString* out, int depth ) 
    464 { 
     467static void toStr_texture( UThread* ut, const UCell* cell, UString* out, 
     468                           int depth ) 
     469{ 
     470    (void) ut; 
    465471    (void) cell; 
    466472    (void) depth; 
    … …  
    469475 
    470476 
    471 static int select_texture( UThread* ur_thread, UCell* val, const UCell* sel, 
     477static int select_texture( UThread* ut, UCell* val, const UCell* sel, 
    472478                           UCell* res ) 
    473479{ 
    … …  
    488494    } 
    489495    if( ri ) 
    490         return select_raster( ur_thread, val, sel, res ); 
     496        return select_raster( ut, val, sel, res ); 
    491497    return 0; 
    492498} 
    … …  
    549555                    case UT_SLICE: 
    550556                        if( cfg.fontFile ) 
    551                             cfg.glyphs = ur_cstring( it ); 
     557                            cfg.glyphs = ur_cstring( ut, it ); 
    552558                        else 
    553                             cfg.fontFile = ur_cstring( it ); 
     559                            cfg.fontFile = ur_cstring( ut, it ); 
    554560                        break; 
    555561 
    … …  
    572578            } 
    573579 
    574             if( ! ur_makeRFont( ur_thread, res, &cfg ) ) 
     580            if( ! ur_makeRFont( ut, res, &cfg ) ) 
    575581                return; 
    576582 
    … …  
    583589 
    584590 
    585 static void toStr_rfont( const UCell* cell, UString* out, int depth ) 
    586 { 
     591static void toStr_rfont( UThread* ut, const UCell* cell, UString* out, 
     592                         int depth ) 
     593{ 
     594    (void) ut; 
    587595    (void) cell; 
    588596    (void) depth; 
    … …