← Back to branch summary

~ubuntu-branches/ubuntu/trusty/psychtoolbox-3/trusty-proposed

« back to all changes in this revision

Viewing changes to Psychtoolbox/PsychOpenGL/MOGL/source/private/mcinfo.m

  • Committer: Package Import Robot
  • Author(s): Yaroslav Halchenko
  • Date: 2013-11-19 23:34:50 UTC
  • mfrom: (3.1.4 experimental)
  • Revision ID: package-import@ubuntu.com-20131119233450-f7nf92vb8qavjmk8
Tags: 3.0.11.20131017.dfsg1-3
Upload to unsable since fresh glew has arrived to sid!

Show diffs side-by-side

added added

removed removed

Lines of Context:
Psychtoolbox/PsychOpenGL/MOGL/source/private/mcinfo.m
8
8
% 24-Jan-2005 -- created;  adapted from code in autocode.m (RFM)
9
9
% 06-Feb-2007 -- Modified; can now handle OpenAL as well. (MK)
10
10
% 24-Mar-2011 -- Modified; Perform 64-bit safe wrapping of encoded memory pointers. (MK)
 
11
% 28-Aug-2012 -- Modified; Handle datatypes GLint64, GLuint64 and GLsync. (MK)
11
12
 
12
13
% make lowercase function name, e.g., glVertex3dv --> gl_vertex3dv
13
14
k=min(find(funcp.fname~=lower(funcp.fname))); %#ok<MXFND>
34
35
% arguments to C function and M-file
35
36
if strcmp(funcp.argouttype.basetype,'void')==0,
36
37
        % scalar return argument
37
 
        if isempty(funcp.argouttype.stars),
 
38
        if isempty(funcp.argouttype.stars) && strcmp(funcp.argouttype.basetype,'GLsync')==0,
38
39
                C.arg_out{1}=sprintf('plhs[0]=mxCreateDoubleMatrix(1,1,mxREAL);\n\t*mxGetPr(plhs[0])=(double)');
39
40
                M.arg_out{1}='r';
40
41
                M.mogl_out{1}='r';
69
70
                funcp.argin.args(j).argname=sprintf('arg%d',j);
70
71
        end
71
72
 
72
 
        % scalar input argument?
73
 
        if isempty(funcp.argin.args(j).type.stars),
 
73
    % 64-Bit (unsigned) integer scalar input argument?
 
74
        if isempty(funcp.argin.args(j).type.stars) && (strcmp(funcp.argin.args(j).type.basetype,'GLint64') || strcmp(funcp.argin.args(j).type.basetype,'GLuint64')),
 
75
        % These need special treatment, as a double scalar can't fully
 
76
        % represent a 64-Bit integer without loss of precision:
 
77
                C.arg_in{end+1}=sprintf('(%s) *((%s*) mxGetData(prhs[%d]))',funcp.argin.args(j).type.full,funcp.argin.args(j).type.basetype,j-1);
 
78
                M.arg_in{end+1}=funcp.argin.args(j).argname;
 
79
        if strcmp(funcp.argin.args(j).type.basetype,'GLint64')
 
80
            % Wrapper needs to cast to int64()
 
81
            M.mogl_in{end+1} = sprintf('int64(%s)', funcp.argin.args(j).argname);
 
82
        else
 
83
            % Wrapper needs to cast to uint64()
 
84
            M.mogl_in{end+1} = sprintf('uint64(%s)', funcp.argin.args(j).argname);
 
85
        end
 
86
        
 
87
    % GLsync handle scalar input argument?
 
88
        elseif isempty(funcp.argin.args(j).type.stars) && strcmp(funcp.argin.args(j).type.basetype,'GLsync'),
 
89
        % New style: Memory pointers are encoded opaque inside double
 
90
        % scalar values. This is 64-bit safe.
 
91
        % TODO: We could also use a mxUINT64_CLASS type aka uint64(), which
 
92
        % would be nicer, but only after we decide to completely drop
 
93
        % support for Matlab versions < R2007a.
 
94
        C.arg_in{end+1}=sprintf('(%s) PsychDoubleToPtr(mxGetScalar(prhs[%d]))',funcp.argin.args(j).type.full,j-1);
 
95
                M.arg_in{end+1}=funcp.argin.args(j).argname;
 
96
                M.arg_in_check{end+1}=sprintf('if ~strcmp(class(%s),''double''),\n\terror([ ''argument ''''%s'''' must be a pointer coded as type double '' ]);\nend\n',funcp.argin.args(j).argname,funcp.argin.args(j).argname);
 
97
                M.mogl_in{end+1}=funcp.argin.args(j).argname;
 
98
        
 
99
        % other scalar input argument?
 
100
    elseif isempty(funcp.argin.args(j).type.stars),
74
101
                C.arg_in{end+1}=sprintf('(%s)mxGetScalar(prhs[%d])',funcp.argin.args(j).type.full,j-1);
75
102
                M.arg_in{end+1}=funcp.argin.args(j).argname;
76
103
                M.mogl_in{end+1}=funcp.argin.args(j).argname;
97
124
                                mcast='double';
98
125
                        case { 'GLfloat' 'GLclampf' 'ALfloat' 'ALclampf' }
99
126
                                mcast='single';
100
 
                        case { 'GLint' 'GLsizei' 'ALint' 'ALsizei' }
 
127
                        case { 'GLint64' }
 
128
                mcast='int64';
 
129
                        case { 'GLuint64' }
 
130
                mcast='uint64';
 
131
            case { 'GLint' 'GLsizei' 'ALint' 'ALsizei' }
101
132
                                mcast='int32';
102
133
                        case { 'GLuint' 'GLenum' 'GLbitfield' 'GLUnurbs' 'GLUtesselator' 'GLUquadric' 'ALuint' 'ALenum' 'ALbitfield' }
103
134
                                mcast='uint32';
111
142
                                mcast='uint8';
112
143
                        case { 'GLvoid' 'void' 'ALvoid' }
113
144
                                mcast='';
114
 
            case { 'GLhandleARB' 'GLhandle' 'ALhandleARB' 'ALhandle' }
 
145
            case { 'GLhandleARB' 'GLhandle' 'ALhandleARB' 'ALhandle' 'GLsync'}
115
146
                % We use a double as an opaque data type for these, as they
116
147
                % can be pointers or integers of 32-bit or 64-bit size.
117
148
                % Safe approach is to use double, as it can contain 64-bits
140
171
                end
141
172
 
142
173
                % if pointer is not void, and is const, then typecast argument
143
 
                if ~isempty(mcast) & ~thisallocate, %#ok<AND2>
 
174
                if ~isempty(mcast) && ~thisallocate,
144
175
                        M.mogl_in{end+1}=sprintf('%s(%s)',mcast,funcp.argin.args(j).argname);
145
176
                else
146
177
                        M.mogl_in{end+1}=sprintf('%s',funcp.argin.args(j).argname);