-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathlibcoscos2dx_ghidra_ext.h
4793 lines (4438 loc) · 233 KB
/
libcoscos2dx_ghidra_ext.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* This file is mostly used as a viewing reference incase something is missing or a function definition needs correcting However this file is becoming obsoltete thanks to the geode-sdk bindings... */
struct CCDataVisitor{
};
void CCDataVisitor::visitObject(this *CCDataVisitor,const CCObject* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCBool* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCInteger* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCFloat* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCDouble* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCString* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCArray* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCDictionary* p);
void CCDataVisitor::visit(this *CCDataVisitor,const CCSet* p);
struct CCPrettyPrinter{
int _indentLevel;
basic_string _indentStr;
basic_string _result;
};
void CCPrettyPrinter::clear(this *CCPrettyPrinter);
basic_string CCPrettyPrinter::getResult(this *CCPrettyPrinter);
void CCPrettyPrinter::visitObject(this *CCPrettyPrinter,const CCObject* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCBool* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCInteger* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCFloat* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCDouble* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCString* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCArray* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCDictionary* p);
void CCPrettyPrinter::visit(this *CCPrettyPrinter,const CCSet* p);
void CCPrettyPrinter::setIndentLevel(this *CCPrettyPrinter,int indentLevel);
struct CCCopying{
};
CCObject* CCCopying::copyWithZone(this *CCCopying,CCZone* pZone);
struct CCObject{
unsigned int m_uID;
int m_nLuaID;
int m_nTag;
unsigned int m_uReference;
unsigned int m_uAutoReleaseCount;
int m_eObjType;
unsigned int m_uObjectIdxInArray;
};
CCObject& CCObject::operator=(this *CCObject);
void CCObject::release(this *CCObject);
void CCObject::retain(this *CCObject);
CCObject* CCObject::autorelease(this *CCObject);
CCObject* CCObject::copy(this *CCObject);
bool CCObject::isSingleReference(this *CCObject);
unsigned int CCObject::retainCount(this *CCObject);
bool CCObject::isEqual(this *CCObject,const CCObject* pObject);
void CCObject::acceptVisitor(this *CCObject,CCDataVisitor& visitor);
void CCObject::update(this *CCObject,float dt);
void CCObject::encodeWithCoder(this *CCObject);
CCObject* CCObject::createWithCoder();
bool CCObject::canEncode(this *CCObject);
CCObjectType CCObject::getObjType(this *CCObject);
int CCObject::getTag(this *CCObject);
void CCObject::setTag(this *CCObject,int nTag);
void CCObject::setObjType(this *CCObject);
struct CCPoint{
float x;
float y;
};
CCPoint& CCPoint::operator=(this *CCPoint,const CCPoint& other);
CCPoint& CCPoint::operator=(this *CCPoint,const CCSize& size);
CCPoint CCPoint::operator+(this *CCPoint,const CCPoint& right);
CCPoint CCPoint::operator-(this *CCPoint,const CCPoint& right);
CCPoint CCPoint::operator-(this *CCPoint);
CCPoint CCPoint::operator*(this *CCPoint,float a);
CCPoint CCPoint::operator/(this *CCPoint,float a);
CCPoint CCPoint::operator*(this *CCPoint,const CCPoint& right);
CCPoint CCPoint::operator/(this *CCPoint,const CCPoint& right);
void CCPoint::setPoint(this *CCPoint,float x,float y);
bool CCPoint::equals(this *CCPoint,const CCPoint& target);
bool CCPoint::fuzzyEquals(this *CCPoint,const CCPoint& target,float variance);
float CCPoint::getLength(this *CCPoint);
float CCPoint::getLengthSq(this *CCPoint);
float CCPoint::getDistanceSq(this *CCPoint,const CCPoint& other);
float CCPoint::getDistance(this *CCPoint,const CCPoint& other);
float CCPoint::getAngle(this *CCPoint);
float CCPoint::getAngle(this *CCPoint,const CCPoint& other);
float CCPoint::dot(this *CCPoint,const CCPoint& other);
float CCPoint::cross(this *CCPoint,const CCPoint& other);
CCPoint CCPoint::getPerp(this *CCPoint);
CCPoint CCPoint::getRPerp(this *CCPoint);
CCPoint CCPoint::project(this *CCPoint,const CCPoint& other);
CCPoint CCPoint::rotate(this *CCPoint,const CCPoint& other);
CCPoint CCPoint::unrotate(this *CCPoint,const CCPoint& other);
CCPoint CCPoint::normalize(this *CCPoint);
CCPoint CCPoint::lerp(this *CCPoint,const CCPoint& other,float alpha);
CCPoint CCPoint::rotateByAngle(this *CCPoint,const CCPoint& pivot,float angle);
CCPoint CCPoint::forAngle(const float a);
struct CCSize{
float width;
float height;
};
CCSize& CCSize::operator=(this *CCSize,const CCSize& other);
CCSize& CCSize::operator=(this *CCSize,const CCPoint& point);
CCSize CCSize::operator+(this *CCSize,const CCSize& right);
CCSize CCSize::operator-(this *CCSize,const CCSize& right);
CCSize CCSize::operator*(this *CCSize,float a);
CCSize CCSize::operator/(this *CCSize,float a);
void CCSize::setSize(this *CCSize,float width,float height);
bool CCSize::equals(this *CCSize,const CCSize& target);
struct CCRect{
CCPoint origin;
CCSize size;
};
CCRect& CCRect::operator=(this *CCRect,const CCRect& other);
void CCRect::setRect(this *CCRect,float x,float y,float width,float height);
float CCRect::getMinX(this *CCRect);
float CCRect::getMidX(this *CCRect);
float CCRect::getMaxX(this *CCRect);
float CCRect::getMinY(this *CCRect);
float CCRect::getMidY(this *CCRect);
float CCRect::getMaxY(this *CCRect);
bool CCRect::equals(this *CCRect,const CCRect& rect);
bool CCRect::containsPoint(this *CCRect,const CCPoint& point);
bool CCRect::intersectsRect(this *CCRect,const CCRect& rect);
struct CCAction{
CCNode* m_pOriginalTarget;
CCNode* m_pTarget;
int m_nTag;
float m_fSpeedMod;
};
const char* CCAction::description(this *CCAction);
CCObject* CCAction::copyWithZone(this *CCAction,CCZone* pZone);
bool CCAction::isDone(this *CCAction);
void CCAction::startWithTarget(this *CCAction,CCNode* pTarget);
void CCAction::stop(this *CCAction);
void CCAction::step(this *CCAction,float dt);
void CCAction::update(this *CCAction,float time);
CCNode* CCAction::getTarget(this *CCAction);
void CCAction::setTarget(this *CCAction,CCNode* pTarget);
CCNode* CCAction::getOriginalTarget(this *CCAction);
void CCAction::setOriginalTarget(this *CCAction,CCNode* pOriginalTarget);
int CCAction::getTag(this *CCAction);
void CCAction::setTag(this *CCAction,int nTag);
void CCAction::setSpeedMod(this *CCAction,float mod);
CCAction* CCAction::create();
struct CCFiniteTimeAction{
float m_fDuration;
};
float CCFiniteTimeAction::getDuration(this *CCFiniteTimeAction);
void CCFiniteTimeAction::setDuration(this *CCFiniteTimeAction,float duration);
CCFiniteTimeAction* CCFiniteTimeAction::reverse(this *CCFiniteTimeAction);
struct CCSpeed{
float m_fSpeed;
CCActionInterval* m_pInnerAction;
};
float CCSpeed::getSpeed(this *CCSpeed);
void CCSpeed::setSpeed(this *CCSpeed,float fSpeed);
bool CCSpeed::initWithAction(this *CCSpeed,CCActionInterval* pAction,float fSpeed);
CCObject* CCSpeed::copyWithZone(this *CCSpeed,CCZone* pZone);
void CCSpeed::startWithTarget(this *CCSpeed,CCNode* pTarget);
void CCSpeed::stop(this *CCSpeed);
void CCSpeed::step(this *CCSpeed,float dt);
bool CCSpeed::isDone(this *CCSpeed);
CCActionInterval* CCSpeed::reverse(this *CCSpeed);
void CCSpeed::setInnerAction(this *CCSpeed,CCActionInterval* pAction);
CCActionInterval* CCSpeed::getInnerAction(this *CCSpeed);
CCSpeed* CCSpeed::create(CCActionInterval* pAction,float fSpeed);
struct CCFollow{
CCNode* m_pobFollowedNode;
bool m_bBoundarySet;
bool m_bBoundaryFullyCovered;
CCPoint m_obHalfScreenSize;
CCPoint m_obFullScreenSize;
float m_fLeftBoundary;
float m_fRightBoundary;
float m_fTopBoundary;
float m_fBottomBoundary;
};
bool CCFollow::isBoundarySet(this *CCFollow);
void CCFollow::setBoudarySet(this *CCFollow,bool bValue);
bool CCFollow::initWithTarget(this *CCFollow,CCNode* pFollowedNode,const CCRect& rect);
CCObject* CCFollow::copyWithZone(this *CCFollow,CCZone* pZone);
void CCFollow::step(this *CCFollow,float dt);
bool CCFollow::isDone(this *CCFollow);
void CCFollow::stop(this *CCFollow);
CCFollow* CCFollow::create(CCNode* pFollowedNode,const CCRect& rect);
struct CCAffineTransform{
float a;
float b;
float c;
float d;
float tx;
float ty;
};
struct _ccArray{
unsigned int num;
unsigned int max;
CCObject** arr;
};
struct _ccCArray{
unsigned int num;
unsigned int max;
void** arr;
};
struct CCArray{
ccArray* data;
};
CCArray* CCArray::create();
CCArray* CCArray::create(CCObject* pObject);
CCArray* CCArray::createWithObject(CCObject* pObject);
CCArray* CCArray::createWithCapacity(unsigned int capacity);
CCArray* CCArray::createWithArray(CCArray* otherArray);
CCArray* CCArray::createWithContentsOfFile(const char* pFileName);
CCArray* CCArray::createWithContentsOfFileThreadSafe(const char* pFileName);
bool CCArray::init(this *CCArray);
bool CCArray::initWithObject(this *CCArray,CCObject* pObject);
bool CCArray::initWithObjects(this *CCArray,CCObject* pObject);
bool CCArray::initWithCapacity(this *CCArray,unsigned int capacity);
bool CCArray::initWithArray(this *CCArray,CCArray* otherArray);
unsigned int CCArray::count(this *CCArray);
unsigned int CCArray::capacity(this *CCArray);
unsigned int CCArray::indexOfObject(this *CCArray,CCObject* object);
CCObject* CCArray::objectAtIndex(this *CCArray,unsigned int index);
CCObject* CCArray::lastObject(this *CCArray);
CCObject* CCArray::randomObject(this *CCArray);
bool CCArray::containsObject(this *CCArray,CCObject* object);
bool CCArray::isEqualToArray(this *CCArray,CCArray* pOtherArray);
void CCArray::addObject(this *CCArray,CCObject* object);
void CCArray::addObjectsFromArray(this *CCArray,CCArray* otherArray);
void CCArray::insertObject(this *CCArray,CCObject* object,unsigned int index);
void CCArray::removeLastObject(this *CCArray,bool bReleaseObj);
void CCArray::removeObject(this *CCArray,CCObject* object,bool bReleaseObj);
void CCArray::removeObjectAtIndex(this *CCArray,unsigned int index,bool bReleaseObj);
void CCArray::removeObjectsInArray(this *CCArray,CCArray* otherArray);
void CCArray::removeAllObjects(this *CCArray);
void CCArray::fastRemoveObject(this *CCArray,CCObject* object);
void CCArray::fastRemoveObjectAtIndex(this *CCArray,unsigned int index);
void CCArray::exchangeObject(this *CCArray,CCObject* object1,CCObject* object2);
void CCArray::exchangeObjectAtIndex(this *CCArray,unsigned int index1,unsigned int index2);
void CCArray::replaceObjectAtIndex(this *CCArray,unsigned int uIndex,CCObject* pObject,bool bReleaseObject);
void CCArray::reverseObjects(this *CCArray);
void CCArray::reduceMemoryFootprint(this *CCArray);
CCObject* CCArray::copyWithZone(this *CCArray,CCZone* pZone);
void CCArray::acceptVisitor(this *CCArray,CCDataVisitor& visitor);
struct CCGLProgram{
GLuint m_uProgram;
GLuint m_uVertShader;
GLuint m_uFragShader;
GLint[kCCUniform_MAX] m_uUniforms;
struct _hashUniformEntry* m_pHashForUniforms;
bool m_bUsesTime;
bool m_hasShaderCompiler;
};
bool CCGLProgram::initWithVertexShaderByteArray(this *CCGLProgram,const GLchar* vShaderByteArray,const GLchar* fShaderByteArray);
bool CCGLProgram::initWithVertexShaderFilename(this *CCGLProgram,const char* vShaderFilename,const char* fShaderFilename);
void CCGLProgram::addAttribute(this *CCGLProgram,const char* attributeName,GLuint index);
bool CCGLProgram::link(this *CCGLProgram);
void CCGLProgram::use(this *CCGLProgram);
void CCGLProgram::updateUniforms(this *CCGLProgram);
GLint CCGLProgram::getUniformLocationForName(this *CCGLProgram,const char* name);
void CCGLProgram::setUniformLocationWith1i(this *CCGLProgram,GLint location,GLint i1);
void CCGLProgram::setUniformLocationWith2i(this *CCGLProgram,GLint location,GLint i1,GLint i2);
void CCGLProgram::setUniformLocationWith3i(this *CCGLProgram,GLint location,GLint i1,GLint i2,GLint i3);
void CCGLProgram::setUniformLocationWith4i(this *CCGLProgram,GLint location,GLint i1,GLint i2,GLint i3,GLint i4);
void CCGLProgram::setUniformLocationWith2iv(this *CCGLProgram,GLint location,GLint* ints,unsigned int numberOfArrays);
void CCGLProgram::setUniformLocationWith3iv(this *CCGLProgram,GLint location,GLint* ints,unsigned int numberOfArrays);
void CCGLProgram::setUniformLocationWith4iv(this *CCGLProgram,GLint location,GLint* ints,unsigned int numberOfArrays);
void CCGLProgram::setUniformLocationWith1f(this *CCGLProgram,GLint location,GLfloat f1);
void CCGLProgram::setUniformLocationWith2f(this *CCGLProgram,GLint location,GLfloat f1,GLfloat f2);
void CCGLProgram::setUniformLocationWith3f(this *CCGLProgram,GLint location,GLfloat f1,GLfloat f2,GLfloat f3);
void CCGLProgram::setUniformLocationWith4f(this *CCGLProgram,GLint location,GLfloat f1,GLfloat f2,GLfloat f3,GLfloat f4);
void CCGLProgram::setUniformLocationWith2fv(this *CCGLProgram,GLint location,GLfloat* floats,unsigned int numberOfArrays);
void CCGLProgram::setUniformLocationWith3fv(this *CCGLProgram,GLint location,GLfloat* floats,unsigned int numberOfArrays);
void CCGLProgram::setUniformLocationWith4fv(this *CCGLProgram,GLint location,GLfloat* floats,unsigned int numberOfArrays);
void CCGLProgram::setUniformLocationWithMatrix4fv(this *CCGLProgram,GLint location,GLfloat* matrixArray,unsigned int numberOfMatrices);
void CCGLProgram::setUniformsForBuiltins(this *CCGLProgram);
const char* CCGLProgram::vertexShaderLog(this *CCGLProgram);
const char* CCGLProgram::fragmentShaderLog(this *CCGLProgram);
const char* CCGLProgram::programLog(this *CCGLProgram);
void CCGLProgram::reset(this *CCGLProgram);
const GLuint CCGLProgram::getProgram(this *CCGLProgram);
bool CCGLProgram::updateUniformLocation(this *CCGLProgram,GLint location,GLvoid* data,unsigned int bytes);
const char* CCGLProgram::description(this *CCGLProgram);
bool CCGLProgram::compileShader(this *CCGLProgram,GLuint* shader,GLenum type,const GLchar* source);
const char* CCGLProgram::logForOpenGLObject(this *CCGLProgram,GLuint object,GLInfoFunction infoFunc,GLLogFunction logFunc);
struct CCTouch{
int m_nId;
bool m_startPointCaptured;
CCPoint m_startPoint;
CCPoint m_point;
CCPoint m_prevPoint;
};
CCPoint CCTouch::getLocation(this *CCTouch);
CCPoint CCTouch::getPreviousLocation(this *CCTouch);
CCPoint CCTouch::getStartLocation(this *CCTouch);
CCPoint CCTouch::getDelta(this *CCTouch);
CCPoint CCTouch::getLocationInView(this *CCTouch);
CCPoint CCTouch::getPreviousLocationInView(this *CCTouch);
CCPoint CCTouch::getStartLocationInView(this *CCTouch);
void CCTouch::setTouchInfo(this *CCTouch,int id,float x,float y);
int CCTouch::getID(this *CCTouch);
struct CCEvent{
};
struct CCSet{
std::set<CCObject*>* m_pSet;
};
CCSet* CCSet::create();
CCSet* CCSet::copy(this *CCSet);
CCSet* CCSet::mutableCopy(this *CCSet);
int CCSet::count(this *CCSet);
void CCSet::addObject(this *CCSet,CCObject* pObject);
void CCSet::removeObject(this *CCSet,CCObject* pObject);
void CCSet::removeAllObjects(this *CCSet);
bool CCSet::containsObject(this *CCSet,CCObject* pObject);
CCSetIterator CCSet::begin(this *CCSet);
CCSetIterator CCSet::end(this *CCSet);
CCObject* CCSet::anyObject(this *CCSet);
void CCSet::acceptVisitor(this *CCSet,CCDataVisitor& visitor);
struct CCScriptHandlerEntry{
int m_nHandler;
int m_nEntryId;
};
CCScriptHandlerEntry* CCScriptHandlerEntry::create(int nHandler);
int CCScriptHandlerEntry::getHandler(this *CCScriptHandlerEntry);
int CCScriptHandlerEntry::getEntryId(this *CCScriptHandlerEntry);
struct CCSchedulerScriptHandlerEntry{
CCTimer* m_pTimer;
bool m_bPaused;
bool m_bMarkedForDeletion;
};
CCSchedulerScriptHandlerEntry* CCSchedulerScriptHandlerEntry::create(int nHandler,float fInterval,bool bPaused);
CCTimer* CCSchedulerScriptHandlerEntry::getTimer(this *CCSchedulerScriptHandlerEntry);
bool CCSchedulerScriptHandlerEntry::isPaused(this *CCSchedulerScriptHandlerEntry);
void CCSchedulerScriptHandlerEntry::markedForDeletion(this *CCSchedulerScriptHandlerEntry);
bool CCSchedulerScriptHandlerEntry::isMarkedForDeletion(this *CCSchedulerScriptHandlerEntry);
bool CCSchedulerScriptHandlerEntry::init(this *CCSchedulerScriptHandlerEntry,float fInterval,bool bPaused);
struct CCTouchScriptHandlerEntry{
bool m_bIsMultiTouches;
int m_nPriority;
bool m_bSwallowsTouches;
};
CCTouchScriptHandlerEntry* CCTouchScriptHandlerEntry::create(int nHandler,bool bIsMultiTouches,int nPriority,bool bSwallowsTouches);
bool CCTouchScriptHandlerEntry::isMultiTouches(this *CCTouchScriptHandlerEntry);
int CCTouchScriptHandlerEntry::getPriority(this *CCTouchScriptHandlerEntry);
bool CCTouchScriptHandlerEntry::getSwallowsTouches(this *CCTouchScriptHandlerEntry);
bool CCTouchScriptHandlerEntry::init(this *CCTouchScriptHandlerEntry,bool bIsMultiTouches,int nPriority,bool bSwallowsTouches);
struct CCScriptEngineProtocol{
};
ccScriptType CCScriptEngineProtocol::getScriptType(this *CCScriptEngineProtocol);
void CCScriptEngineProtocol::removeScriptObjectByCCObject(this *CCScriptEngineProtocol,CCObject* pObj);
void CCScriptEngineProtocol::removeScriptHandler(this *CCScriptEngineProtocol,int nHandler);
int CCScriptEngineProtocol::reallocateScriptHandler(this *CCScriptEngineProtocol,int nHandler);
int CCScriptEngineProtocol::executeString(this *CCScriptEngineProtocol,const char* codes);
int CCScriptEngineProtocol::executeScriptFile(this *CCScriptEngineProtocol,const char* filename);
int CCScriptEngineProtocol::executeGlobalFunction(this *CCScriptEngineProtocol,const char* functionName);
int CCScriptEngineProtocol::executeNodeEvent(this *CCScriptEngineProtocol,CCNode* pNode,int nAction);
int CCScriptEngineProtocol::executeMenuItemEvent(this *CCScriptEngineProtocol,CCMenuItem* pMenuItem);
int CCScriptEngineProtocol::executeNotificationEvent(this *CCScriptEngineProtocol,CCNotificationCenter* pNotificationCenter,const char* pszName);
int CCScriptEngineProtocol::executeCallFuncActionEvent(this *CCScriptEngineProtocol,CCCallFunc* pAction,CCObject* pTarget);
int CCScriptEngineProtocol::executeSchedule(this *CCScriptEngineProtocol,int nHandler,float dt,CCNode* pNode);
int CCScriptEngineProtocol::executeLayerTouchesEvent(this *CCScriptEngineProtocol,CCLayer* pLayer,int eventType,CCSet* pTouches);
int CCScriptEngineProtocol::executeLayerTouchEvent(this *CCScriptEngineProtocol,CCLayer* pLayer,int eventType,CCTouch* pTouch);
int CCScriptEngineProtocol::executeLayerKeypadEvent(this *CCScriptEngineProtocol,CCLayer* pLayer,int eventType);
int CCScriptEngineProtocol::executeAccelerometerEvent(this *CCScriptEngineProtocol,CCLayer* pLayer,CCAcceleration* pAccelerationValue);
int CCScriptEngineProtocol::executeEvent(this *CCScriptEngineProtocol,int nHandler,const char* pEventName,CCObject* pEventSource,const char* pEventSourceClassName);
int CCScriptEngineProtocol::executeEventWithArgs(this *CCScriptEngineProtocol,int nHandler,CCArray* pArgs);
bool CCScriptEngineProtocol::handleAssert(this *CCScriptEngineProtocol,const char* msg);
bool CCScriptEngineProtocol::parseConfig(this *CCScriptEngineProtocol,ConfigType type,const basic_string& str);
struct CCScriptEngineManager{
CCScriptEngineProtocol* m_pScriptEngine;
};
CCScriptEngineProtocol* CCScriptEngineManager::getScriptEngine(this *CCScriptEngineManager);
void CCScriptEngineManager::setScriptEngine(this *CCScriptEngineManager,CCScriptEngineProtocol* pScriptEngine);
void CCScriptEngineManager::removeScriptEngine(this *CCScriptEngineManager);
CCScriptEngineManager* CCScriptEngineManager::sharedManager();
void CCScriptEngineManager::purgeSharedManager();
struct _ccColor3B{
GLubyte r;
GLubyte g;
GLubyte b;
};
struct _ccHSVValue{
float h;
float s;
float v;
GLubyte absoluteSaturation;
GLubyte absoluteBrightness;
unsigned char[2] __pad;
};
struct _ccColor4B{
GLubyte r;
GLubyte g;
GLubyte b;
GLubyte a;
};
struct _ccColor4F{
GLfloat r;
GLfloat g;
GLfloat b;
GLfloat a;
};
struct _ccVertex2F{
GLfloat x;
GLfloat y;
};
struct _ccVertex3F{
GLfloat x;
GLfloat y;
GLfloat z;
};
struct _ccTex2F{
GLfloat u;
GLfloat v;
};
struct _ccPointSprite{
ccVertex2F pos;
ccColor4B color;
GLfloat size;
};
struct _ccQuad2{
ccVertex2F tl;
ccVertex2F tr;
ccVertex2F bl;
ccVertex2F br;
};
struct _ccQuad3{
ccVertex3F bl;
ccVertex3F br;
ccVertex3F tl;
ccVertex3F tr;
};
struct _ccV2F_C4B_T2F{
ccVertex2F vertices;
ccColor4B colors;
ccTex2F texCoords;
};
struct _ccV2F_C4F_T2F{
ccVertex2F vertices;
ccColor4F colors;
ccTex2F texCoords;
};
struct _ccV3F_C4B_T2F{
ccVertex3F vertices;
ccColor4B colors;
ccTex2F texCoords;
};
struct _ccV2F_C4B_T2F_Triangle{
ccV2F_C4B_T2F a;
ccV2F_C4B_T2F b;
ccV2F_C4B_T2F c;
};
struct _ccV2F_C4B_T2F_Quad{
ccV2F_C4B_T2F bl;
ccV2F_C4B_T2F br;
ccV2F_C4B_T2F tl;
ccV2F_C4B_T2F tr;
};
struct _ccV3F_C4B_T2F_Quad{
ccV3F_C4B_T2F tl;
ccV3F_C4B_T2F bl;
ccV3F_C4B_T2F tr;
ccV3F_C4B_T2F br;
};
struct _ccV2F_C4F_T2F_Quad{
ccV2F_C4F_T2F bl;
ccV2F_C4F_T2F br;
ccV2F_C4F_T2F tl;
ccV2F_C4F_T2F tr;
};
struct _ccBlendFunc{
GLenum src;
GLenum dst;
};
struct _ccT2F_Quad{
ccTex2F bl;
ccTex2F br;
ccTex2F tl;
ccTex2F tr;
};
struct _ccFontShadow{
bool m_shadowEnabled;
CCSize m_shadowOffset;
float m_shadowBlur;
float m_shadowOpacity;
};
struct _ccFontStroke{
bool m_strokeEnabled;
ccColor3B m_strokeColor;
float m_strokeSize;
};
struct _ccFontDefinition{
basic_string m_fontName;
int m_fontSize;
CCTextAlignment m_alignment;
CCVerticalTextAlignment m_vertAlignment;
CCSize m_dimensions;
ccColor3B m_fontFillColor;
ccFontShadow m_shadow;
ccFontStroke m_stroke;
};
struct _ccTexParams{
GLuint minFilter;
GLuint magFilter;
GLuint wrapS;
GLuint wrapT;
};
struct CCTexture2D{
bool m_bPVRHaveAlphaPremultiplied;
CCTexture2DPixelFormat m_ePixelFormat;
unsigned int m_uPixelsWide;
unsigned int m_uPixelsHigh;
GLuint m_uName;
GLfloat m_fMaxS;
GLfloat m_fMaxT;
CCSize m_tContentSize;
bool m_bHasPremultipliedAlpha;
bool m_bHasMipmaps;
CCGLProgram* m_pShaderProgram;
};
const char* CCTexture2D::description(this *CCTexture2D);
void CCTexture2D::releaseData(this *CCTexture2D,void* data);
void* CCTexture2D::keepData(this *CCTexture2D,void* data,unsigned int length);
bool CCTexture2D::initWithData(this *CCTexture2D,const void* data,CCTexture2DPixelFormat pixelFormat,unsigned int pixelsWide,unsigned int pixelsHigh,const CCSize& contentSize);
void CCTexture2D::drawAtPoint(this *CCTexture2D,const CCPoint& point);
void CCTexture2D::drawInRect(this *CCTexture2D,const CCRect& rect);
bool CCTexture2D::initWithImage(this *CCTexture2D,CCImage* uiImage);
bool CCTexture2D::initWithString(this *CCTexture2D,const char* text,const char* fontName,float fontSize,const CCSize& dimensions,CCTextAlignment hAlignment,CCVerticalTextAlignment vAlignment);
bool CCTexture2D::initWithString(this *CCTexture2D,const char* text,const char* fontName,float fontSize);
bool CCTexture2D::initWithString(this *CCTexture2D,const char* text,ccFontDefinition* textDefinition);
bool CCTexture2D::initWithPVRFile(this *CCTexture2D,const char* file);
bool CCTexture2D::initWithETCFile(this *CCTexture2D,const char* file);
void CCTexture2D::setTexParameters(this *CCTexture2D,ccTexParams* texParams);
void CCTexture2D::setAntiAliasTexParameters(this *CCTexture2D);
void CCTexture2D::setAliasTexParameters(this *CCTexture2D);
void CCTexture2D::generateMipmap(this *CCTexture2D);
const char* CCTexture2D::stringForFormat(this *CCTexture2D);
unsigned int CCTexture2D::bitsPerPixelForFormat(this *CCTexture2D);
unsigned int CCTexture2D::bitsPerPixelForFormat(this *CCTexture2D,CCTexture2DPixelFormat format);
void CCTexture2D::setDefaultAlphaPixelFormat(CCTexture2DPixelFormat format);
CCTexture2DPixelFormat CCTexture2D::defaultAlphaPixelFormat();
void CCTexture2D::PVRImagesHavePremultipliedAlpha(bool haveAlphaPremultiplied);
const CCSize& CCTexture2D::getContentSizeInPixels(this *CCTexture2D);
bool CCTexture2D::hasPremultipliedAlpha(this *CCTexture2D);
bool CCTexture2D::hasMipmaps(this *CCTexture2D);
bool CCTexture2D::initPremultipliedATextureWithImage(this *CCTexture2D,CCImage* image,unsigned int pixelsWide,unsigned int pixelsHigh);
CCTexture2DPixelFormat CCTexture2D::getPixelFormat(this *CCTexture2D);
unsigned int CCTexture2D::getPixelsWide(this *CCTexture2D);
unsigned int CCTexture2D::getPixelsHigh(this *CCTexture2D);
GLuint CCTexture2D::getName(this *CCTexture2D);
GLfloat CCTexture2D::getMaxS(this *CCTexture2D);
void CCTexture2D::setMaxS(this *CCTexture2D,GLfloat var);
GLfloat CCTexture2D::getMaxT(this *CCTexture2D);
void CCTexture2D::setMaxT(this *CCTexture2D,GLfloat var);
CCSize CCTexture2D::getContentSize(this *CCTexture2D);
CCGLProgram* CCTexture2D::getShaderProgram(this *CCTexture2D);
void CCTexture2D::setShaderProgram(this *CCTexture2D,CCGLProgram* var);
struct CCRGBAProtocol{
};
void CCRGBAProtocol::setColor(this *CCRGBAProtocol,const ccColor3B& color);
const ccColor3B& CCRGBAProtocol::getColor(this *CCRGBAProtocol);
const ccColor3B& CCRGBAProtocol::getDisplayedColor(this *CCRGBAProtocol);
GLubyte CCRGBAProtocol::getDisplayedOpacity(this *CCRGBAProtocol);
GLubyte CCRGBAProtocol::getOpacity(this *CCRGBAProtocol);
void CCRGBAProtocol::setOpacity(this *CCRGBAProtocol,GLubyte opacity);
void CCRGBAProtocol::setOpacityModifyRGB(this *CCRGBAProtocol,bool bValue);
bool CCRGBAProtocol::isOpacityModifyRGB(this *CCRGBAProtocol);
bool CCRGBAProtocol::isCascadeColorEnabled(this *CCRGBAProtocol);
void CCRGBAProtocol::setCascadeColorEnabled(this *CCRGBAProtocol,bool cascadeColorEnabled);
void CCRGBAProtocol::updateDisplayedColor(this *CCRGBAProtocol,const ccColor3B& color);
bool CCRGBAProtocol::isCascadeOpacityEnabled(this *CCRGBAProtocol);
void CCRGBAProtocol::setCascadeOpacityEnabled(this *CCRGBAProtocol,bool cascadeOpacityEnabled);
void CCRGBAProtocol::updateDisplayedOpacity(this *CCRGBAProtocol,GLubyte opacity);
struct CCBlendProtocol{
};
void CCBlendProtocol::setBlendFunc(this *CCBlendProtocol,ccBlendFunc blendFunc);
ccBlendFunc CCBlendProtocol::getBlendFunc(this *CCBlendProtocol);
struct CCTextureProtocol{
};
CCTexture2D* CCTextureProtocol::getTexture(this *CCTextureProtocol);
void CCTextureProtocol::setTexture(this *CCTextureProtocol,CCTexture2D* texture);
struct CCLabelProtocol{
};
void CCLabelProtocol::setString(this *CCLabelProtocol,const char* label);
const char* CCLabelProtocol::getString(this *CCLabelProtocol);
struct CCDirectorDelegate{
};
void CCDirectorDelegate::updateProjection(this *CCDirectorDelegate);
struct CCNode{
float m_fRotationX;
float m_fRotationY;
float m_fScaleX;
float m_fScaleY;
float m_fVertexZ;
CCPoint m_obPosition;
float m_fSkewX;
float m_fSkewY;
CCPoint m_obAnchorPointInPoints;
CCPoint m_obAnchorPoint;
CCSize m_obContentSize;
CCAffineTransform m_sAdditionalTransform;
CCAffineTransform m_sTransform;
CCAffineTransform m_sInverse;
CCCamera* m_pCamera;
CCGridBase* m_pGrid;
int m_nZOrder;
CCArray* m_pChildren;
CCNode* m_pParent;
void* m_pUserData;
CCObject* m_pUserObject;
CCGLProgram* m_pShaderProgram;
ccGLServerState m_eGLServerState;
unsigned int m_uOrderOfArrival;
CCScheduler* m_pScheduler;
CCActionManager* m_pActionManager;
bool m_bRunning;
bool m_bTransformDirty;
bool m_bInverseDirty;
bool m_bAdditionalTransformDirty;
bool m_bVisible;
bool m_bIgnoreAnchorPointForPosition;
bool m_bReorderChildDirty;
int m_nScriptHandler;
int m_nUpdateScriptHandler;
ccScriptType m_eScriptType;
CCComponentContainer* m_pComponentContainer;
};
bool CCNode::init(this *CCNode);
CCNode* CCNode::create();
const char* CCNode::description(this *CCNode);
void CCNode::setZOrder(this *CCNode,int zOrder);
void CCNode::_setZOrder(this *CCNode,int z);
int CCNode::getZOrder(this *CCNode);
void CCNode::setVertexZ(this *CCNode,float vertexZ);
float CCNode::getVertexZ(this *CCNode);
void CCNode::setScaleX(this *CCNode,float fScaleX);
float CCNode::getScaleX(this *CCNode);
void CCNode::setScaleY(this *CCNode,float fScaleY);
float CCNode::getScaleY(this *CCNode);
void CCNode::setScale(this *CCNode,float scale);
float CCNode::getScale(this *CCNode);
void CCNode::setScale(this *CCNode,float fScaleX,float fScaleY);
void CCNode::setPosition(this *CCNode,const CCPoint& position);
const CCPoint& CCNode::getPosition(this *CCNode);
void CCNode::setPosition(this *CCNode,float x,float y);
void CCNode::getPosition(this *CCNode,float* x,float* y);
void CCNode::setPositionX(this *CCNode,float x);
float CCNode::getPositionX(this *CCNode);
void CCNode::setPositionY(this *CCNode,float y);
float CCNode::getPositionY(this *CCNode);
void CCNode::setSkewX(this *CCNode,float fSkewX);
float CCNode::getSkewX(this *CCNode);
void CCNode::setSkewY(this *CCNode,float fSkewY);
float CCNode::getSkewY(this *CCNode);
void CCNode::setAnchorPoint(this *CCNode,const CCPoint& anchorPoint);
const CCPoint& CCNode::getAnchorPoint(this *CCNode);
const CCPoint& CCNode::getAnchorPointInPoints(this *CCNode);
void CCNode::setContentSize(this *CCNode,const CCSize& contentSize);
const CCSize& CCNode::getContentSize(this *CCNode);
CCSize CCNode::getScaledContentSize(this *CCNode);
void CCNode::setVisible(this *CCNode,bool visible);
bool CCNode::isVisible(this *CCNode);
void CCNode::setRotation(this *CCNode,float fRotation);
float CCNode::getRotation(this *CCNode);
void CCNode::setRotationX(this *CCNode,float fRotaionX);
float CCNode::getRotationX(this *CCNode);
void CCNode::setRotationY(this *CCNode,float fRotationY);
float CCNode::getRotationY(this *CCNode);
void CCNode::setOrderOfArrival(this *CCNode,unsigned int uOrderOfArrival);
unsigned int CCNode::getOrderOfArrival(this *CCNode);
void CCNode::setGLServerState(this *CCNode,ccGLServerState glServerState);
ccGLServerState CCNode::getGLServerState(this *CCNode);
void CCNode::ignoreAnchorPointForPosition(this *CCNode,bool ignore);
bool CCNode::isIgnoreAnchorPointForPosition(this *CCNode);
void CCNode::addChild(this *CCNode,CCNode* child);
void CCNode::addChild(this *CCNode,CCNode* child,int zOrder);
void CCNode::addChild(this *CCNode,CCNode* child,int zOrder,int tag);
CCNode* CCNode::getChildByTag(this *CCNode,int tag);
CCArray* CCNode::getChildren(this *CCNode);
unsigned int CCNode::getChildrenCount(this *CCNode);
void CCNode::setParent(this *CCNode,CCNode* parent);
CCNode* CCNode::getParent(this *CCNode);
void CCNode::removeFromParent(this *CCNode);
void CCNode::removeFromParentAndCleanup(this *CCNode,bool cleanup);
void CCNode::removeMeAndCleanup(this *CCNode);
void CCNode::removeChild(this *CCNode,CCNode* child);
void CCNode::removeChild(this *CCNode,CCNode* child,bool cleanup);
void CCNode::removeChildByTag(this *CCNode,int tag);
void CCNode::removeChildByTag(this *CCNode,int tag,bool cleanup);
void CCNode::removeAllChildren(this *CCNode);
void CCNode::removeAllChildrenWithCleanup(this *CCNode,bool cleanup);
void CCNode::reorderChild(this *CCNode,CCNode* child,int zOrder);
void CCNode::sortAllChildren(this *CCNode);
CCGridBase* CCNode::getGrid(this *CCNode);
void CCNode::setGrid(this *CCNode,CCGridBase* pGrid);
void* CCNode::getUserData(this *CCNode);
void CCNode::setUserData(this *CCNode,void* pUserData);
CCObject* CCNode::getUserObject(this *CCNode);
void CCNode::setUserObject(this *CCNode,CCObject* pUserObject);
CCGLProgram* CCNode::getShaderProgram(this *CCNode);
void CCNode::setShaderProgram(this *CCNode,CCGLProgram* pShaderProgram);
CCCamera* CCNode::getCamera(this *CCNode);
bool CCNode::isRunning(this *CCNode);
void CCNode::registerScriptHandler(this *CCNode,int handler);
void CCNode::unregisterScriptHandler(this *CCNode);
int CCNode::getScriptHandler(this *CCNode);
void CCNode::scheduleUpdateWithPriorityLua(this *CCNode,int nHandler,int priority);
void CCNode::onEnter(this *CCNode);
void CCNode::onEnterTransitionDidFinish(this *CCNode);
void CCNode::onExit(this *CCNode);
void CCNode::onExitTransitionDidStart(this *CCNode);
void CCNode::cleanup(this *CCNode);
void CCNode::draw(this *CCNode);
void CCNode::visit(this *CCNode);
CCRect CCNode::boundingBox(this *CCNode);
void CCNode::setActionManager(this *CCNode,CCActionManager* actionManager);
CCActionManager* CCNode::getActionManager(this *CCNode);
CCAction* CCNode::runAction(this *CCNode,CCAction* action);
void CCNode::stopAllActions(this *CCNode);
void CCNode::stopAction(this *CCNode,CCAction* action);
void CCNode::stopActionByTag(this *CCNode,int tag);
CCAction* CCNode::getActionByTag(this *CCNode,int tag);
unsigned int CCNode::numberOfRunningActions(this *CCNode);
void CCNode::setScheduler(this *CCNode,CCScheduler* scheduler);
CCScheduler* CCNode::getScheduler(this *CCNode);
bool CCNode::isScheduled(this *CCNode,SEL_SCHEDULE selector);
void CCNode::scheduleUpdate(this *CCNode);
void CCNode::scheduleUpdateWithPriority(this *CCNode,int priority);
void CCNode::unscheduleUpdate(this *CCNode);
void CCNode::schedule(this *CCNode,SEL_SCHEDULE selector,float interval,unsigned int repeat,float delay);
void CCNode::schedule(this *CCNode,SEL_SCHEDULE selector,float interval);
void CCNode::scheduleOnce(this *CCNode,SEL_SCHEDULE selector,float delay);
void CCNode::schedule(this *CCNode,SEL_SCHEDULE selector);
void CCNode::unschedule(this *CCNode,SEL_SCHEDULE selector);
void CCNode::unscheduleAllSelectors(this *CCNode);
void CCNode::resumeSchedulerAndActions(this *CCNode);
void CCNode::pauseSchedulerAndActions(this *CCNode);
void CCNode::update(this *CCNode,float delta);
void CCNode::transform(this *CCNode);
void CCNode::transformAncestors(this *CCNode);
void CCNode::updateTransform(this *CCNode);
const CCAffineTransform CCNode::nodeToParentTransform(this *CCNode);
const CCAffineTransform CCNode::parentToNodeTransform(this *CCNode);
CCAffineTransform CCNode::nodeToWorldTransform(this *CCNode);
CCAffineTransform CCNode::worldToNodeTransform(this *CCNode);
CCPoint CCNode::convertToNodeSpace(this *CCNode,const CCPoint& worldPoint);
CCPoint CCNode::convertToWorldSpace(this *CCNode,const CCPoint& nodePoint);
CCPoint CCNode::convertToNodeSpaceAR(this *CCNode,const CCPoint& worldPoint);
CCPoint CCNode::convertToWorldSpaceAR(this *CCNode,const CCPoint& nodePoint);
CCPoint CCNode::convertTouchToNodeSpace(this *CCNode,CCTouch* touch);
CCPoint CCNode::convertTouchToNodeSpaceAR(this *CCNode,CCTouch* touch);
void CCNode::setAdditionalTransform(this *CCNode,const CCAffineTransform& additionalTransform);
CCComponent* CCNode::getComponent(this *CCNode,const char* pName);
bool CCNode::addComponent(this *CCNode,CCComponent* pComponent);
bool CCNode::removeComponent(this *CCNode,const char* pName);
bool CCNode::removeComponent(this *CCNode,CCComponent* pComponent);
void CCNode::removeAllComponents(this *CCNode);
void CCNode::updateTweenAction(this *CCNode);
CCNode& CCNode::operator=(this *CCNode);
void CCNode::childrenAlloc(this *CCNode);
void CCNode::insertChild(this *CCNode,CCNode* child,int z);
void CCNode::detachChild(this *CCNode,CCNode* child,bool doCleanup);
CCPoint CCNode::convertToWindowSpace(this *CCNode,const CCPoint& nodePoint);
struct CCNodeRGBA{
GLubyte _displayedOpacity;
GLubyte _realOpacity;
ccColor3B _displayedColor;
ccColor3B _realColor;
bool _cascadeColorEnabled;
bool _cascadeOpacityEnabled;
};
bool CCNodeRGBA::init(this *CCNodeRGBA);
CCNodeRGBA* CCNodeRGBA::create();
GLubyte CCNodeRGBA::getOpacity(this *CCNodeRGBA);
GLubyte CCNodeRGBA::getDisplayedOpacity(this *CCNodeRGBA);
void CCNodeRGBA::setOpacity(this *CCNodeRGBA,GLubyte opacity);
void CCNodeRGBA::updateDisplayedOpacity(this *CCNodeRGBA,GLubyte parentOpacity);
bool CCNodeRGBA::isCascadeOpacityEnabled(this *CCNodeRGBA);
void CCNodeRGBA::setCascadeOpacityEnabled(this *CCNodeRGBA,bool cascadeOpacityEnabled);
const ccColor3B& CCNodeRGBA::getColor(this *CCNodeRGBA);
const ccColor3B& CCNodeRGBA::getDisplayedColor(this *CCNodeRGBA);
void CCNodeRGBA::setColor(this *CCNodeRGBA,const ccColor3B& color);
void CCNodeRGBA::updateDisplayedColor(this *CCNodeRGBA,const ccColor3B& parentColor);
bool CCNodeRGBA::isCascadeColorEnabled(this *CCNodeRGBA);
void CCNodeRGBA::setCascadeColorEnabled(this *CCNodeRGBA,bool cascadeColorEnabled);
void CCNodeRGBA::setOpacityModifyRGB(this *CCNodeRGBA,bool bValue);
bool CCNodeRGBA::isOpacityModifyRGB(this *CCNodeRGBA);
struct CCSpriteFrame{
CCPoint m_obOffset;
CCSize m_obOriginalSize;
CCRect m_obRectInPixels;
bool m_bRotated;
CCRect m_obRect;
CCPoint m_obOffsetInPixels;
CCSize m_obOriginalSizeInPixels;
CCTexture2D* m_pobTexture;
basic_string m_strTextureFilename;
};
const CCRect& CCSpriteFrame::getRectInPixels(this *CCSpriteFrame);
void CCSpriteFrame::setRectInPixels(this *CCSpriteFrame,const CCRect& rectInPixels);
bool CCSpriteFrame::isRotated(this *CCSpriteFrame);
void CCSpriteFrame::setRotated(this *CCSpriteFrame,bool bRotated);
const CCRect& CCSpriteFrame::getRect(this *CCSpriteFrame);
void CCSpriteFrame::setRect(this *CCSpriteFrame,const CCRect& rect);
const CCPoint& CCSpriteFrame::getOffsetInPixels(this *CCSpriteFrame);
void CCSpriteFrame::setOffsetInPixels(this *CCSpriteFrame,const CCPoint& offsetInPixels);
const CCSize& CCSpriteFrame::getOriginalSizeInPixels(this *CCSpriteFrame);
void CCSpriteFrame::setOriginalSizeInPixels(this *CCSpriteFrame,const CCSize& sizeInPixels);
const CCSize& CCSpriteFrame::getOriginalSize(this *CCSpriteFrame);
void CCSpriteFrame::setOriginalSize(this *CCSpriteFrame,const CCSize& sizeInPixels);
CCTexture2D* CCSpriteFrame::getTexture(this *CCSpriteFrame);
void CCSpriteFrame::setTexture(this *CCSpriteFrame,CCTexture2D* pobTexture);
const CCPoint& CCSpriteFrame::getOffset(this *CCSpriteFrame);
void CCSpriteFrame::setOffset(this *CCSpriteFrame,const CCPoint& offsets);
CCObject* CCSpriteFrame::copyWithZone(this *CCSpriteFrame,CCZone* pZone);
CCSpriteFrame* CCSpriteFrame::create(const char* filename,const CCRect& rect);
CCSpriteFrame* CCSpriteFrame::create(const char* filename,const CCRect& rect,bool rotated,const CCPoint& offset,const CCSize& originalSize);
CCSpriteFrame* CCSpriteFrame::createWithTexture(CCTexture2D* pobTexture,const CCRect& rect);
CCSpriteFrame* CCSpriteFrame::createWithTexture(CCTexture2D* pobTexture,const CCRect& rect,bool rotated,const CCPoint& offset,const CCSize& originalSize);
bool CCSpriteFrame::initWithTexture(this *CCSpriteFrame,CCTexture2D* pobTexture,const CCRect& rect);
bool CCSpriteFrame::initWithTextureFilename(this *CCSpriteFrame,const char* filename,const CCRect& rect);
bool CCSpriteFrame::initWithTexture(this *CCSpriteFrame,CCTexture2D* pobTexture,const CCRect& rect,bool rotated,const CCPoint& offset,const CCSize& originalSize);
bool CCSpriteFrame::initWithTextureFilename(this *CCSpriteFrame,const char* filename,const CCRect& rect,bool rotated,const CCPoint& offset,const CCSize& originalSize);
struct UT_hash_bucket{
struct UT_hash_handle* hh_head;
unsigned count;
unsigned expand_mult;
};
struct UT_hash_table{
UT_hash_bucket* buckets;
unsigned num_buckets;
unsigned log2_num_buckets;
unsigned num_items;
struct UT_hash_handle* tail;
ptrdiff_t hho;
unsigned ideal_chain_maxlen;
unsigned nonideal_items;
unsigned ineff_expands;
unsigned noexpand;
uint32_t signature;
};
struct UT_hash_handle{
struct UT_hash_table* tbl;
void* prev;
void* next;
struct UT_hash_handle* hh_prev;
struct UT_hash_handle* hh_next;
void* key;
unsigned keylen;
unsigned hashv;
};
struct CCString{
basic_string m_sString;
};
CCString& CCString::operator=(this *CCString,const CCString& other);
bool CCString::initWithFormat(this *CCString,const char* format);
int CCString::intValue(this *CCString);
unsigned int CCString::uintValue(this *CCString);
float CCString::floatValue(this *CCString);
double CCString::doubleValue(this *CCString);
bool CCString::boolValue(this *CCString);
const char* CCString::getCString(this *CCString);
unsigned int CCString::length(this *CCString);
int CCString::compare(this *CCString);
CCObject* CCString::copyWithZone(this *CCString,CCZone* pZone);
bool CCString::isEqual(this *CCString,const CCObject* pObject);
CCString* CCString::create(const basic_string& str);
CCString* CCString::createWithFormat(const char* format);
CCString* CCString::createWithData(const unsigned char* pData,unsigned long nLen);
CCString* CCString::createWithContentsOfFile(const char* pszFileName);
void CCString::acceptVisitor(this *CCString,CCDataVisitor& visitor);
bool CCString::initWithFormatAndValist(this *CCString,const char* format,va_list ap);
struct CCDictElement{
char[256] m_szKey;
intptr_t m_iKey;
CCObject* m_pObject;
UT_hash_handle hh;
};
const char* CCDictElement::getStrKey(this *CCDictElement);
intptr_t CCDictElement::getIntKey(this *CCDictElement);
CCObject* CCDictElement::getObject(this *CCDictElement);
struct CCDictionary{
CCDictElement* m_pElements;
CCDictType m_eDictType;
};
unsigned int CCDictionary::count(this *CCDictionary);
CCArray* CCDictionary::allKeys(this *CCDictionary);
CCArray* CCDictionary::allKeysForObject(this *CCDictionary,CCObject* object);
CCObject* CCDictionary::objectForKey(this *CCDictionary,const basic_string& key);
CCObject* CCDictionary::objectForKey(this *CCDictionary,intptr_t key);
const CCString* CCDictionary::valueForKey(this *CCDictionary,const basic_string& key);
const CCString* CCDictionary::valueForKey(this *CCDictionary,intptr_t key);
void CCDictionary::setObject(this *CCDictionary,CCObject* pObject,const basic_string& key);
void CCDictionary::setObject(this *CCDictionary,CCObject* pObject,intptr_t key);
void CCDictionary::removeObjectForKey(this *CCDictionary,const basic_string& key);
void CCDictionary::removeObjectForKey(this *CCDictionary,intptr_t key);
void CCDictionary::removeObjectsForKeys(this *CCDictionary,CCArray* pKeyArray);
void CCDictionary::removeObjectForElememt(this *CCDictionary,CCDictElement* pElement);
void CCDictionary::removeAllObjects(this *CCDictionary);
CCObject* CCDictionary::copyWithZone(this *CCDictionary,CCZone* pZone);
CCObject* CCDictionary::randomObject(this *CCDictionary);
CCDictionary* CCDictionary::create();
CCDictionary* CCDictionary::createWithDictionary(CCDictionary* srcDict);
CCDictionary* CCDictionary::createWithContentsOfFile(const char* pFileName);
bool CCDictionary::writeToFile(this *CCDictionary,const char* fullPath);
CCDictionary* CCDictionary::createWithContentsOfFileThreadSafe(const char* pFileName);
void CCDictionary::acceptVisitor(this *CCDictionary,CCDataVisitor& visitor);
void CCDictionary::setObjectUnSafe(this *CCDictionary,CCObject* pObject,const basic_string& key);
void CCDictionary::setObjectUnSafe(this *CCDictionary,CCObject* pObject,const intptr_t key);
struct CCAnimationFrame{
CCSpriteFrame* m_pSpriteFrame;
float m_fDelayUnits;
CCDictionary* m_pUserInfo;
};
CCObject* CCAnimationFrame::copyWithZone(this *CCAnimationFrame,CCZone* pZone);
bool CCAnimationFrame::initWithSpriteFrame(this *CCAnimationFrame,CCSpriteFrame* spriteFrame,float delayUnits,CCDictionary* userInfo);
CCSpriteFrame* CCAnimationFrame::getSpriteFrame(this *CCAnimationFrame);
void CCAnimationFrame::setSpriteFrame(this *CCAnimationFrame,CCSpriteFrame* var);
float CCAnimationFrame::getDelayUnits(this *CCAnimationFrame);
void CCAnimationFrame::setDelayUnits(this *CCAnimationFrame,float var);
CCDictionary* CCAnimationFrame::getUserInfo(this *CCAnimationFrame);
void CCAnimationFrame::setUserInfo(this *CCAnimationFrame,CCDictionary* var);
struct CCAnimation{
float m_fTotalDelayUnits;
float m_fDelayPerUnit;
float m_fDuration;
CCArray* m_pFrames;
bool m_bRestoreOriginalFrame;
unsigned int m_uLoops;
};
CCAnimation* CCAnimation::create();
CCAnimation* CCAnimation::createWithSpriteFrames(CCArray* arrayOfSpriteFrameNames,float delay);
CCAnimation* CCAnimation::create(CCArray* arrayOfAnimationFrameNames,float delayPerUnit,unsigned int loops);
CCAnimation* CCAnimation::create(CCArray* arrayOfAnimationFrameNames,float delayPerUnit);
void CCAnimation::addSpriteFrame(this *CCAnimation,CCSpriteFrame* pFrame);
void CCAnimation::addSpriteFrameWithFileName(this *CCAnimation,const char* pszFileName);