RSS

(root)/iphone/common : 61 : MarineCompass/source/EAGLView.m

To get this branch, use:
bzr branch /browse/iphone/common

« back to all changes in this revision

Viewing changes to MarineCompass/source/EAGLView.m

Dömötör Gulyás
2010-01-18 09:03:51
Revision ID: dognotdog@gmail.com-20100118080351-ib2knxvk4w8ssw3h
made common a nested tree

Show diffs side-by-side

added added

removed removed

MarineCompass/source/EAGLView.m
1
 
//
2
 
//  EAGLView.m
3
 
//  MarineCompass
4
 
//
5
 
//  Created by döme on 26.07.2009.
6
 
//  Copyright __MyCompanyName__ 2009. All rights reserved.
7
 
//
8
 
 
9
 
 
10
 
 
11
 
#import <QuartzCore/QuartzCore.h>
12
 
#import <OpenGLES/EAGLDrawable.h>
13
 
#import <CoreGraphics/CoreGraphics.h>
14
 
 
15
 
#import "EAGLView.h"
16
 
 
17
 
#import "geometry.h"
18
 
#import "ESShader.h"
19
 
#import "ES2Shader.h"
20
 
#import "VertexArray.h"
21
 
#import "MarineCompassAppDelegate.h"
22
 
 
23
 
 
24
 
enum
25
 
{
26
 
        kProjectionModePerspective,
27
 
        kProjectionModeOrtho,
28
 
        kProjectionModeLast
29
 
};
30
 
 
31
 
enum
32
 
{
33
 
        kLinesModeNone,
34
 
        kLinesModeFront,
35
 
        kLinesModeBoth,
36
 
        kLinesModeBack,
37
 
        kLinesModeLast
38
 
};
39
 
 
40
 
enum
41
 
{
42
 
        kViewpointNormal,
43
 
        kViewpointOnDisc,
44
 
        kViewpointLast
45
 
};
46
 
 
47
 
 
48
 
 
49
 
@implementation EAGLView
50
 
 
51
 
 
52
 
 
53
 
- (void) setupGraphicsForApi: (EAGLRenderingAPI) glApi
54
 
{
55
 
 
56
 
        glEnable(GL_DEPTH_TEST);
57
 
        //glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
58
 
        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
59
 
                                        
60
 
        [self loadTextureFromBitmapNamed: @"scale1.1024.png" texName: &scale1tex repeat: NO mipmap: NO filter: YES];
61
 
        [self loadTextureFromBitmapNamed: @"scale2.1024.png" texName: &scale2tex repeat: NO mipmap: NO filter: YES];
62
 
        [self loadTextureFromBitmapNamed: @"lines.1024.png" texName: &linesTex repeat: NO mipmap: NO filter: YES];
63
 
        [self loadTextureFromBitmapNamed: @"disk1.png" texName: &disk1tex repeat: NO mipmap: NO filter: YES];
64
 
        [self loadTextureFromBitmapNamed: @"disk2.png" texName: &disk2tex repeat: NO mipmap: NO filter: YES];
65
 
        [self loadTextureFromBitmapNamed: @"white.png" texName: &whiteTex repeat: NO mipmap: NO filter: NO];
66
 
        [self loadTextureFromBitmapNamed: @"gray.png" texName: &grayTex repeat: NO mipmap: NO filter: NO];
67
 
 
68
 
        outerConeVar = [[VertexArray coneWithFraction: (0.3)] retain];
69
 
        sphereVar = [[VertexArray sharedSphere] retain];
70
 
        
71
 
        simpleShader = [[[ESShader shader] initWithVertexShaderFile: @"simple.vs" fragmentShaderFile:  @"simple.fs"] retain];
72
 
        fresnelShader = [[[ESShader shader] initWithVertexShaderFile: @"fresnel.vs" fragmentShaderFile: @"fresnel.fs"] retain];
73
 
 
74
 
}
75
 
 
76
 
- (void)drawView
77
 
{
78
 
        [self setupViewDrawing];
79
 
        
80
 
        m16 mv = [(id)[[UIApplication sharedApplication] delegate] baseCompassTransform];
81
 
        
82
 
    const GLfloat axisVertices[] = {
83
 
        0.0f,   0.0f,   0.0f,
84
 
        1.0f,   0.0f,   0.0f,
85
 
        0.0f,   0.0f,   0.0f,
86
 
        0.0f,   1.0f,   0.0f,
87
 
        0.0f,   0.0f,   0.0f,
88
 
        0.0f,   0.0f,   1.0f,
89
 
    };
90
 
    const GLubyte axisColors[] = {
91
 
        255,    0,      0,      255,
92
 
        255,    0,      0,      255,
93
 
        0,      255,    0,      255,
94
 
        0,      255,    0,      255,
95
 
        0,      0,      255,    255,
96
 
        0,      0,      255,    255,
97
 
    };
98
 
    
99
 
        
100
 
        [simpleShader bindShader];
101
 
        
102
 
        m16 pm = midentity();
103
 
        CGRect frame = [self frame];
104
 
        float ar = frame.size.width/frame.size.height;
105
 
        
106
 
        switch (viewpointMode)
107
 
        {
108
 
                case kViewpointNormal:
109
 
                        switch (projectionMode)
110
 
                        {
111
 
                                case kProjectionModePerspective:
112
 
                                {
113
 
                                        pm = mperspective(50.0*(M_PI/180.0), ar, 1.5, 4.5);
114
 
                                        break;
115
 
                                }
116
 
                                case kProjectionModeOrtho:
117
 
                                        pm = mortho(-1.1,1.1, -1.1/ar, 1.1/ar, 1.5, 4.5);
118
 
                                        break;
119
 
                        }
120
 
                        break;
121
 
                case kViewpointOnDisc:
122
 
                        switch (projectionMode)
123
 
                        {
124
 
                                case kProjectionModePerspective:
125
 
                                {
126
 
                                        pm = mperspective(50.0*(M_PI/180.0), ar, 0.01, 2.0);
127
 
                                        break;
128
 
                                }
129
 
                                case kProjectionModeOrtho:
130
 
                                        pm = mortho(-0.55,0.55, -0.55/ar, 0.55/ar, -1.5, 1.5);
131
 
                                        break;
132
 
                        }
133
 
                        break;
134
 
        }
135
 
    
136
 
        [simpleShader setProjectionMatrix: &pm];
137
 
//      glMatrixMode(GL_PROJECTION);
138
 
//      glLoadIdentity();
139
 
//      glFrustumf(-0.5, 0.5, -0.75, 0.75, 1.0, 4.0);
140
 
 
141
 
//      glMatrixMode(GL_MODELVIEW);
142
 
//      glLoadIdentity();
143
 
 
144
 
//      GLfloat lightpos[] = {0.0,0.0,0.0,1.0};
145
 
//      glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
146
 
//      glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
147
 
 
148
 
 
149
 
        m16 baseFrame = mv;
150
 
 
151
 
        switch (viewpointMode)
152
 
        {
153
 
        case kViewpointNormal:
154
 
                baseFrame = mmul(mtranslate(vcreate(-0.2*mv.m[2][0], -0.3*mv.m[2][1], -0.5*(1.5+4.5))), mv);
155
 
                //baseFrame = mmul(mtranslate(vcreate(0.0, 0.0, -0.5*(1.5+4.5))), mv);
156
 
                break;
157
 
        case kViewpointOnDisc:
158
 
                baseFrame = mmul(mtranslate(vcreate(-0.2*mv.m[2][0], -0.2*mv.m[2][1], -0.2*mv.m[2][2])), mv);
159
 
                break;
160
 
        }
161
 
        
162
 
        
163
 
/*
164
 
    glVertexPointer(3, GL_FLOAT, 0, axisVertices);
165
 
    glEnableClientState(GL_VERTEX_ARRAY);
166
 
    glColorPointer(4, GL_UNSIGNED_BYTE, 0, axisColors);
167
 
    glEnableClientState(GL_COLOR_ARRAY);
168
 
    
169
 
                glDrawArrays(GL_LINES, 0, 6);
170
 
*/
171
 
/*      
172
 
        if (0) {
173
 
        float compassVertices[12] = {0.0f,0.0f,0.15f, cvflat.v.x, cvflat.v.y, 0.15f,
174
 
                                                                0.0f,0.0f,0.0f, cvn.v.x, cvn.v.y, cvn.v.z};
175
 
 
176
 
        glDisableClientState(GL_COLOR_ARRAY);
177
 
 
178
 
        glVertexPointer(3, GL_FLOAT, 0, compassVertices);
179
 
        glEnableClientState(GL_VERTEX_ARRAY);
180
 
 
181
 
    glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
182
 
                glDrawArrays(GL_LINES, 0, 2);
183
 
    glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
184
 
                glDrawArrays(GL_LINES, 2, 2);
185
 
        }
186
 
*/
187
 
 
188
 
        float textureOffset = 17.5/1024.0;
189
 
        float textureScale = 900.0/1024.0;
190
 
 
191
 
        {
192
 
        
193
 
/*              
194
 
                glMatrixMode(GL_TEXTURE);
195
 
                glLoadIdentity();
196
 
                glTranslatef(textureOffset+1.0/1024.0, 0.0,0.0);
197
 
                glScalef(textureScale,1.0,1.0);
198
 
*/
199
 
 
200
 
                m16 mvc = [(id)[[UIApplication sharedApplication] delegate] compassDiskTransform];
201
 
                
202
 
                m16 compassFrame = mmul(baseFrame, mvc);
203
 
                
204
 
                [simpleShader setModelviewMatrix: &compassFrame];
205
 
                
206
 
//              glEnable(GL_COLOR_MATERIAL);
207
 
//              glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
208
 
                glEnable(GL_BLEND);
209
 
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
210
 
//              glEnable(GL_LIGHTING);
211
 
//              glEnable(GL_LIGHT0);
212
 
//              glDisableClientState(GL_COLOR_ARRAY);
213
 
                glEnable(GL_TEXTURE_2D);
214
 
                glBindTexture(GL_TEXTURE_2D, scale1tex);
215
 
 
216
 
                m16 cylTM = mmul(mtranslate(vcreate(textureOffset+0.0/1024.0, 0.0,0.0)), mscale(vcreate(textureScale,1.0,1.0)));
217
 
                [simpleShader setTextureMatrix: &cylTM];
218
 
                
219
 
                m16 cylinderFrame = mmul(compassFrame, mscale(vcreate(1.0,1.0,0.2)));
220
 
                [simpleShader setModelviewMatrix: &cylinderFrame];
221
 
 
222
 
                glEnable(GL_CULL_FACE);
223
 
                glCullFace(GL_FRONT);
224
 
                
225
 
                [[VertexArray sharedCylinder] draw];
226
 
 
227
 
                glCullFace(GL_BACK);
228
 
                [[VertexArray sharedCylinder] draw];
229
 
 
230
 
                glDisable(GL_CULL_FACE);
231
 
                
232
 
                m16 diskFrame = mmul(compassFrame, mmul(mtranslate(vcreate(0.0,0.0,0.05)), mscale(vcreate(0.7,0.7,1.0))));
233
 
                [simpleShader setModelviewMatrix: &diskFrame];
234
 
 
235
 
                glBindTexture(GL_TEXTURE_2D, disk1tex);
236
 
                
237
 
                m16 I = midentity();
238
 
                [simpleShader setTextureMatrix: &I];
239
 
                
240
 
                [[VertexArray sharedDisk] draw];
241
 
                
242
 
                glBindTexture(GL_TEXTURE_2D, disk2tex);
243
 
                m16 diskFrame2 = mmul(compassFrame, mmul(mtranslate(vcreate(0.0,0.0,-0.2)), mscale(vcreate(1.0,1.0,1.0))));
244
 
                [simpleShader setModelviewMatrix: &diskFrame2];
245
 
                [[VertexArray sharedDisk] draw];
246
 
                
247
 
                                
248
 
                glBindTexture(GL_TEXTURE_2D, scale2tex);
249
 
                
250
 
/*
251
 
                glMatrixMode(GL_TEXTURE);
252
 
                glLoadIdentity();
253
 
                glTranslatef(textureOffset, 0.0,0.0);
254
 
                glScalef(textureScale,1.0,1.0);
255
 
*/
256
 
                m16 coneTM = mmul(mtranslate(vcreate(textureOffset, 0.0,0.0)), mscale(vcreate(textureScale,1.0,1.0)));
257
 
                [simpleShader setTextureMatrix: &coneTM];
258
 
 
259
 
                m16 coneFrame = mmul(compassFrame, mmul(mtranslate(vcreate(0.0,0.0,0.2)), mscale(vcreate(1.0, 1.0, -0.5))));
260
 
                
261
 
                coneFrame = mmul(coneFrame, mcreatefrombases(vcreate(-1.0,0.0,0.0), vcreate(0.0,-1.0,0.0), vcreate(0.0,0.0,1.0)));
262
 
                
263
 
                [simpleShader setModelviewMatrix: &coneFrame];
264
 
                
265
 
                
266
 
 
267
 
                //glRotatef(180.0, 0.0, 0.0, 1.0);
268
 
 
269
 
                [outerConeVar draw];            
270
 
                
271
 
 
272
 
        }
273
 
 
274
 
        if (0)
275
 
        {
276
 
                glEnable(GL_BLEND);
277
 
                glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
278
 
                glEnable(GL_CULL_FACE);
279
 
                glCullFace(GL_BACK);
280
 
                [fresnelShader bindShader];
281
 
                
282
 
                m16 sphereFrame = mmul(baseFrame, mscale(vcreate(1.1,1.1,1.1)));
283
 
                m16 I = midentity();
284
 
                
285
 
                [fresnelShader setProjectionMatrix: &pm];
286
 
                [fresnelShader setModelviewMatrix: &sphereFrame];
287
 
                [fresnelShader setTextureMatrix: &I];
288
 
                
289
 
                glBindTexture(GL_TEXTURE_2D, whiteTex);
290
 
                
291
 
                [sphereVar draw];
292
 
        }
293
 
 
294
 
 
295
 
        if (linesMode)
296
 
        {               
297
 
                m16 mt = mtranspose(mv);
298
 
                
299
 
                v3 Z = vcreate(0.0,0.0,1.0);
300
 
                v3 camZ = mtransformdir3(mt, Z);
301
 
                
302
 
                camZ.v.z = 0.0;
303
 
                camZ = vnormalize(camZ);
304
 
                
305
 
                v3 camY = vnormalize(vcross(Z, camZ));
306
 
                
307
 
                m16 mc = mcreatefrombases(camZ, camY, Z);
308
 
                
309
 
                m16 gaugeFrame = mmul(mmul(baseFrame, mc), mscale(vcreate(1.03,1.03,1.03)));
310
 
                
311
 
                [simpleShader setModelviewMatrix: &gaugeFrame];
312
 
                
313
 
                m16 tm = mmul( mtranslate(vcreate(0.0,-1.0,0.0)), mscale(vcreate(1.0,3.0,1.0)));
314
 
                tm = mmul(tm, mmul(mtranslate(vcreate(textureOffset, 0.0,0.0)), mscale(vcreate(textureScale,1.0,1.0))));
315
 
                
316
 
                
317
 
                glBindTexture(GL_TEXTURE_2D, linesTex);
318
 
                
319
 
                glDepthMask(GL_FALSE);
320
 
                
321
 
                glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
322
 
                glEnable(GL_CULL_FACE);
323
 
                if (linesMode > 1)
324
 
                {
325
 
                        m16 tm1 = mmul(tm, mtranslate(vcreate(0.5, 0.0, 0.0)));
326
 
                        m16 mv1 = mmul(gaugeFrame, mcreatefrombases(vcreate(-1.0,0.0,0.0), vcreate(0.0,-1.0,0.0), vcreate(0.0,0.0,1.0)));
327
 
                        [simpleShader setModelviewMatrix: &mv1];
328
 
                        [simpleShader setTextureMatrix: &tm1];
329
 
                        glCullFace(GL_FRONT);
330
 
                        [[VertexArray sharedXSemiSphere] draw];
331
 
                        glCullFace(GL_BACK);
332
 
                        [[VertexArray sharedXSemiSphere] draw];
333
 
                }
334
 
                if (linesMode < 3)
335
 
                {
336
 
                        m16 tm1 = mmul(tm, mtranslate(vcreate(1.0, 0.0, 0.0)));
337
 
                        [simpleShader setModelviewMatrix: &gaugeFrame];
338
 
 
339
 
                        glCullFace(GL_FRONT);
340
 
                        [simpleShader setTextureMatrix: &tm];
341
 
                        [[VertexArray sharedXSemiSphere] draw];
342
 
                        [simpleShader setTextureMatrix: &tm1];
343
 
                        [[VertexArray sharedXSemiSphere] draw];
344
 
                        glCullFace(GL_BACK);
345
 
                        [simpleShader setTextureMatrix: &tm];
346
 
                        [[VertexArray sharedXSemiSphere] draw];
347
 
                        [simpleShader setTextureMatrix: &tm1];
348
 
                        [[VertexArray sharedXSemiSphere] draw];
349
 
                }
350
 
 
351
 
                glDepthMask(GL_TRUE);
352
 
 
353
 
        }
354
 
 
355
 
        [self finishViewDrawing];
356
 
}
357
 
 
358
 
 
359
 
 
360
 
- (void) animationCallback: (id) info
361
 
{
362
 
        //NSLog(@"animatin");
363
 
        [self drawView];
364
 
}
365
 
 
366
 
- (void) dealloc 
367
 
{
368
 
        
369
 
    if ([EAGLContext currentContext] == context) {
370
 
        [EAGLContext setCurrentContext:nil];
371
 
    }
372
 
    
373
 
    [context release];  
374
 
    [super dealloc];
375
 
}
376
 
 
377
 
- (IBAction) toggleProjectionMode: (id) sender
378
 
{
379
 
        projectionMode = (projectionMode+1) % kProjectionModeLast;
380
 
        
381
 
        switch(projectionMode)
382
 
        {
383
 
                case kProjectionModeOrtho:
384
 
                        [sender setImage: [UIImage imageNamed: @"perspective.png"]];
385
 
                        break;
386
 
                case kProjectionModePerspective:
387
 
                        [sender setImage: [UIImage imageNamed: @"ortho.png"]];
388
 
                        break;
389
 
        }
390
 
}
391
 
 
392
 
- (IBAction) toggleLinesMode: (id) sender
393
 
{
394
 
        linesMode = (linesMode+1) % kLinesModeLast;
395
 
        
396
 
        [sender setImage: [UIImage imageNamed: [NSString stringWithFormat: @"lines%d.png", (linesMode+1) % kLinesModeLast]]];
397
 
}
398
 
 
399
 
- (IBAction) toggleViewpointMode: (id) sender
400
 
{
401
 
        viewpointMode = (viewpointMode+1) % kViewpointLast;
402
 
        
403
 
        switch(viewpointMode)
404
 
        {
405
 
                case kViewpointNormal:
406
 
                        [sender setStyle: UIBarButtonItemStyleBordered];
407
 
                        //[sender setImage: [UIImage imageNamed: @"sliceIcon.png"]];
408
 
                        break;
409
 
                case kViewpointOnDisc:
410
 
                        [sender setStyle: UIBarButtonItemStyleDone];
411
 
                        //[sender setImage: [UIImage imageNamed: @"circleIcon.png"]];
412
 
                        break;
413
 
        }
414
 
}
415
 
 
416
 
 
417
 
@end

Loggerhead 1.17 is a web-based interface for Bazaar branches