API: AIMesh.h Source File

00001 #ifndef __AIMesh__
00002 #define __AIMesh__
00003 
00004 /*
00005  *        Name: AIMesh.h
00006  *   $Revision: 27 $
00007  *      Author:
00008  *        Date:
00009  *     Purpose: Adobe Illustrator Mesh Object Suite.
00010  *
00011  * ADOBE SYSTEMS INCORPORATED
00012  * Copyright 1986-2007 Adobe Systems Incorporated.
00013  * All rights reserved.
00014  *
00015  * NOTICE:  Adobe permits you to use, modify, and distribute this file
00016  * in accordance with the terms of the Adobe license agreement
00017  * accompanying it. If you have received this file from a source other
00018  * than Adobe, then your use, modification, or distribution of it
00019  * requires the prior written permission of Adobe.
00020  *
00021  */
00022 
00023 
00024 /*******************************************************************************
00025  **
00026  **     Imports
00027  **
00028  **/
00029 
00030 #ifndef __AITypes__
00031 #include "AITypes.h"
00032 #endif
00033 
00034 #ifndef __AIArt__
00035 #include "AIArt.h"
00036 #endif
00037 
00038 #ifndef __AIColor__
00039 #include "AIColor.h"
00040 #endif
00041 
00042 #ifndef __AIHitTest__
00043 #include "AIHitTest.h"
00044 #endif
00045 
00046 #ifndef __AIRealBezier__
00047 #include "AIRealBezier.h"
00048 #endif
00049 
00050 #include "AIHeaderBegin.h"
00051 
00054 /*******************************************************************************
00055  **
00056  **     Constants
00057  **
00058  **/
00059 
00060 #define kAIMeshSuite                                                    "AI Mesh Suite"
00061 #define kAIMeshSuiteVersion6                                    AIAPI_VERSION(6)
00062 #define kAIMeshSuiteVersion                                             kAIMeshSuiteVersion6
00063 #define kAIMeshVersion                                                  kAIMeshSuiteVersion
00064 
00065 #define kAIMeshHitSuite                                                 "AI Mesh Hit Suite"
00066 #define kAIMeshHitSuiteVersion3                                 AIAPI_VERSION(3)
00067 #define kAIMeshHitSuiteVersion                                  kAIMeshHitSuiteVersion3
00068 #define kAIMeshHitVersion                                               kAIMeshHitSuiteVersion
00069 
00070 #define kAIMeshSelectionSuite                                   "AI Mesh Selection Suite"
00071 #define kAIMeshSelectionSuiteVersion3                   AIAPI_VERSION(3)
00072 #define kAIMeshSelectionSuiteVersion                    kAIMeshSelectionSuiteVersion3
00073 #define kAIMeshSelectionVersion                                 kAIMeshSelectionSuiteVersion
00074 
00075 #define kAIMeshPatchIteratorSuite                               "AI Mesh Patch Suite"
00076 #define kAIMeshPatchIteratorSuiteVersion3               AIAPI_VERSION(3)
00077 #define kAIMeshPatchIteratorSuiteVersion                kAIMeshPatchIteratorSuiteVersion3
00078 #define kAIMeshPatchIteratorVersion                             kAIMeshPatchIteratorSuiteVersion
00079 
00080 #define kAIMeshVertexIteratorSuite                              "AI Mesh Vertex Suite"
00081 #define kAIMeshVertexIteratorSuiteVersion4              AIAPI_VERSION(4)
00082 #define kAIMeshVertexIteratorSuiteVersion               kAIMeshVertexIteratorSuiteVersion4
00083 #define kAIMeshVertexIteratorVersion                    kAIMeshVertexIteratorSuiteVersion
00084 
00085 #define kAIMeshSegmentIteratorSuite                             "AI Mesh Segment Suite"
00086 #define kAIMeshSegmentIteratorSuiteVersion3             AIAPI_VERSION(3)
00087 #define kAIMeshSegmentIteratorSuiteVersion              kAIMeshSegmentIteratorSuiteVersion3
00088 #define kAIMeshSegmentIteratorVersion                   kAIMeshSegmentIteratorSuiteVersion
00089 
00090 
00092 enum AIMeshKind {
00094         kAICartesianMesh                                = 0,
00096         kAIPolarMesh                                    = 1
00097 };
00098 
00100 enum AIMeshAxis {
00102         kAIMeshIAxis                                    = 0,
00104         kAIMeshJAxis                                    = 1
00105 };
00106 
00108 enum AIMeshAxisSense {
00109         kAIMeshAxisIncreasing                   = 0,
00110         kAIMeshAxisDecreasing                   = 1
00111 };
00112 
00114 enum AIMeshPatchDirection {
00115         kAIMeshClockwise                                = 0,
00116         kAIMeshCounterClockwise                 = 1
00117 };
00118 
00120 enum AIMeshPart {
00121         kAIMeshNowhere                                  = 0,
00122         kAIMeshVertex                                   = 1,
00123         kAIMeshTangent                                  = 2,
00124         kAIMeshEdge                                             = 3,
00125         kAIMeshPatch                                    = 4
00126 };
00127 
00129 enum AIMeshSelectionBoundsVariant {
00134         kAIMeshSelectionRigidBounds             = 0
00135 };
00136 
00137 
00138 /*******************************************************************************
00139  **
00140  **     Types
00141  **
00142  **/
00143 
00145 typedef struct _AIMeshSelection                 *AIMeshSelection;
00147 typedef struct _AIMeshPatchIterator             *AIMeshPatchIterator;
00149 typedef struct _AIMeshVertexIterator    *AIMeshVertexIterator;
00151 typedef struct _AIMeshSegmentIterator   *AIMeshSegmentIterator;
00152 
00153 
00160 typedef void (*AIMeshPointMap) (AIRealPoint* point, void* userData);
00166 typedef void (*AIMeshColorMap) (AIColor* color, void* userData);
00167 
00173 typedef void (*AIMeshColorQuery) (AIColor* color, void* userData);
00174 
00175 
00176 /*******************************************************************************
00177  **
00178  **     Suite
00179  **
00180  **/
00181 
00182 
00277 typedef struct {
00278 
00285         AIAPI AIErr (*InitCartesian) (AIArtHandle mesh, ai::int32 i, ai::int32 j);
00286 
00288         AIAPI AIErr (*InitPolar) (AIArtHandle mesh, ai::int32 i, ai::int32 j);
00289 
00294         AIAPI AIErr (*GetKind) (AIArtHandle mesh, ai::int32 *kind);
00295 
00301         AIAPI AIErr (*GetSize) (AIArtHandle mesh, ai::int32 *i, ai::int32 *j);
00302 
00311         AIAPI AIErr (*NewSelection) (AIArtHandle mesh, AIBoolean all, AIMeshSelection* selection);
00312 
00318         AIAPI AIErr (*GetSelection) (AIArtHandle mesh, AIMeshSelection* selection);
00319 
00326         AIAPI AIErr (*GetPatch) (AIArtHandle mesh, ai::int32 i, ai::int32 j, AIMeshPatchIterator* patch);
00327 
00333         AIAPI AIErr (*GetStartPatch) (AIArtHandle mesh, AIMeshPatchIterator* patch);
00334 
00341         AIAPI AIErr (*GetNode) (AIArtHandle mesh, ai::int32 i, ai::int32 j, AIMeshVertexIterator* vertex);
00342 
00348         AIAPI AIErr (*GetStartVertex) (AIArtHandle mesh, AIMeshVertexIterator* vertex);
00349 
00355         AIAPI AIErr (*GetStartSegment) (AIArtHandle mesh, AIMeshSegmentIterator* segment);
00356 
00367         AIAPI void (*GetColorSpace) (AIArtHandle mesh, AIColorTag* kind, AICustomColorHandle* custom);
00368 
00380         AIAPI AIBoolean (*InvertPoint) (AIArtHandle mesh, AIRealPoint* point, AIReal* u, AIReal* v);
00381 
00389         AIAPI void (*EvalPoint) (AIArtHandle mesh, AIReal u, AIReal v, AIRealPoint* point);
00390 
00398         AIAPI void (*EvalColor) (AIArtHandle mesh, AIReal u, AIReal v, AIColor* color);
00399 
00407         AIAPI void (*EvalOpacity) (AIArtHandle mesh, AIReal u, AIReal v, AIReal* opacity);
00408 
00413         AIAPI AIErr (*Transform) (AIArtHandle mesh, AIRealMatrix* matrix);
00414 
00421         AIAPI AIErr (*MapPoints) (AIArtHandle mesh, AIMeshPointMap f, void* userData);
00422 
00429         AIAPI AIErr (*MapColors) (AIArtHandle mesh, AIMeshColorMap f, void* userData);
00430 
00438         AIAPI void (*QueryColors) (AIArtHandle mesh, AIMeshColorQuery f, void* userData);
00439 
00446         AIAPI AIErr (*InsertU) (AIArtHandle mesh, AIReal u, ai::int32* i);
00447 
00454         AIAPI AIErr (*InsertV) (AIArtHandle mesh, AIReal v, ai::int32* j);
00455 
00465         AIAPI AIErr (*DeleteGridLines) (AIArtHandle mesh, AIReal u, AIReal v);
00466 
00478         AIAPI void (*TrackBegin) (AIArtHandle mesh);
00479 
00485         AIAPI void (*TrackEnd) (AIArtHandle mesh);
00486 
00494         AIAPI AIErr (*EndSelectionChanges) (void);
00495 
00503         AIAPI AIErr (*DropColor) (AIHitRef hit, const AIColor* color);
00504 
00511         AIAPI AIErr (*GetRelativeU) (AIArtHandle mesh, ai::int32 i, AIReal* u);
00512 
00519         AIAPI AIErr (*GetRelativeV) (AIArtHandle mesh, ai::int32 j, AIReal* v);
00520 
00526         AIAPI AIBoolean (*GetOverprint) (AIArtHandle mesh);
00527 
00532         AIAPI AIErr (*SetOverprint) (AIArtHandle mesh, AIBoolean overprint);
00533 
00534 } AIMeshSuite;
00535 
00536 
00548 typedef struct {
00549 
00555         AIAPI ai::int32 (*GetPart) (AIHitRef hit);
00556 
00566         AIAPI void (*GetUV) (AIHitRef hit, AIReal* u, AIReal* v);
00567 
00573         AIAPI AIErr (*GetSelection) (AIHitRef hit, AIMeshSelection* selection);
00574 
00579         AIAPI AIErr (*GetVertex) (AIHitRef hit, AIMeshVertexIterator* vertex);
00580 
00585         AIAPI AIErr (*GetTangentIndex) (AIHitRef hit, ai::int32* index);
00586 
00591         AIAPI AIErr (*GetSegment) (AIHitRef hit, AIMeshSegmentIterator* segment);
00592 
00597         AIAPI AIErr (*GetPatch) (AIHitRef hit, AIMeshPatchIterator* patch);
00598 
00599 } AIMeshHitSuite;
00600 
00601 
00623 typedef struct {
00624 
00632         AIAPI ai::int32 (*AddRef) (AIMeshSelection selection);
00633 
00640         AIAPI ai::int32 (*Release) (AIMeshSelection selection);
00641 
00646         AIAPI AIErr (*Copy) (AIMeshSelection selection, AIMeshSelection from);
00647 
00652         AIAPI AIErr (*Clone) (AIMeshSelection selection, AIMeshSelection* clone);
00653 
00659         AIAPI AIBoolean (*IsEmpty) (AIMeshSelection selection);
00660 
00666         AIAPI AIBoolean (*IsFull) (AIMeshSelection selection);
00667 
00674         AIAPI AIBoolean (*IsEqual) (AIMeshSelection selection1, AIMeshSelection selection2);
00675 
00683         AIAPI AIBoolean (*Contains) (AIMeshSelection selection1, AIMeshSelection selection2);
00684 
00691         AIAPI AIBoolean (*ContainsVertex) (AIMeshSelection selection, AIMeshVertexIterator vertex);
00692 
00699         AIAPI AIBoolean (*ContainsSegment) (AIMeshSelection selection, AIMeshSegmentIterator segment);
00700 
00708         AIAPI AIBoolean (*RendersControl) (AIMeshSelection selection, AIMeshSegmentIterator segment);
00709 
00714         AIAPI AIErr (*Intersect) (AIMeshSelection selection1, AIMeshSelection selection2);
00715 
00720         AIAPI AIErr (*Union) (AIMeshSelection selection1, AIMeshSelection selection2);
00721 
00728         AIAPI AIErr (*Invert) (AIMeshSelection selection1, AIMeshSelection selection2);
00729 
00735         AIAPI AIErr (*SelectPatch) (AIMeshSelection selection, AIMeshPatchIterator patch, AIBoolean select);
00736 
00742         AIAPI AIErr (*SelectVertex) (AIMeshSelection selection, AIMeshVertexIterator vertex, AIBoolean select);
00743 
00749         AIAPI AIErr (*SelectSegment) (AIMeshSelection selection, AIMeshSegmentIterator segment, AIBoolean select);
00750 
00755         AIAPI AIErr (*Transform) (AIMeshSelection selection, AIRealMatrix* matrix);
00756 
00763         AIAPI AIErr (*MapPoints) (AIMeshSelection selection, AIMeshPointMap f, void* userData);
00764 
00771         AIAPI AIErr (*MapColors) (AIMeshSelection selection, AIMeshColorMap f, void* userData);
00772 
00780         AIAPI void (*QueryColors) (AIMeshSelection selection, AIMeshColorQuery f, void* userData);
00781 
00792         AIAPI void (*BoundPieces) (AIMeshSelection selection, AIRealMatrix* matrix, ai::int32 variant, AIRealRect* bounds);
00793 
00794 } AIMeshSelectionSuite;
00795 
00796 
00806 typedef struct {
00807 
00815         AIAPI ai::int32 (*AddRef) (AIMeshPatchIterator patch);
00816 
00823         AIAPI ai::int32 (*Release) (AIMeshPatchIterator patch);
00824 
00829         AIAPI AIErr (*Copy) (AIMeshPatchIterator patch, AIMeshPatchIterator from);
00830 
00835         AIAPI AIErr (*Clone) (AIMeshPatchIterator patch, AIMeshPatchIterator* clone);
00836 
00843         AIAPI AIBoolean (*IsEqual) (AIMeshPatchIterator patch1, AIMeshPatchIterator patch2);
00844 
00854         AIAPI AIBoolean (*AtEnd) (AIMeshPatchIterator patch);
00855 
00865         AIAPI void (*Next) (AIMeshPatchIterator patch);
00866 
00873         AIAPI void (*Prev) (AIMeshPatchIterator patch);
00874 
00881         AIAPI void (*NextI) (AIMeshPatchIterator patch);
00882 
00889         AIAPI void (*PrevI) (AIMeshPatchIterator patch);
00890 
00897         AIAPI void (*NextJ) (AIMeshPatchIterator patch);
00898 
00905         AIAPI void (*PrevJ) (AIMeshPatchIterator patch);
00906 
00912         AIAPI ai::int32 (*CountNodes) (AIMeshPatchIterator patch);
00913 
00921         AIAPI AIErr (*GetNodeN) (AIMeshPatchIterator patch, ai::int32 n, AIMeshVertexIterator* vertex);
00922 
00930         AIAPI AIErr (*GetNodeIJ) (AIMeshPatchIterator patch, ai::int32 i, ai::int32 j, AIMeshVertexIterator* vertex);
00931 
00942         AIAPI AIErr (*GetSegmentN) (AIMeshPatchIterator patch, ai::int32 n, ai::int32 direction, AIMeshSegmentIterator* segment);
00943 
00955         AIAPI AIErr (*GetSegmentIJ) (AIMeshPatchIterator patch, ai::int32 i, ai::int32 j, ai::int32 direction, AIMeshSegmentIterator* segment);
00956 
00964         AIAPI ai::int32 (*CountVerticies) (AIMeshPatchIterator patch);
00965 
00973         AIAPI AIErr (*GetVertexM) (AIMeshPatchIterator patch, ai::int32 m, AIMeshVertexIterator* vertex);
00974 
00985         AIAPI AIErr (*GetSegmentM) (AIMeshPatchIterator patch, ai::int32 m, ai::int32 direction, AIMeshSegmentIterator* segment);
00986 
00992         AIAPI AIErr (*FindVertex) (AIMeshPatchIterator patch, AIMeshVertexIterator vertex, ai::int32* m);
00993 
00999         AIAPI void (*GetIJ) (AIMeshPatchIterator patch, ai::int32* i, ai::int32* j);
01000 
01001 } AIMeshPatchIteratorSuite;
01002 
01003 
01015 typedef struct {
01023         AIAPI ai::int32 (*AddRef) (AIMeshVertexIterator vertex);
01024 
01031         AIAPI ai::int32 (*Release) (AIMeshVertexIterator vertex);
01032 
01037         AIAPI AIErr (*Copy) (AIMeshVertexIterator vertex, AIMeshVertexIterator from);
01038 
01043         AIAPI AIErr (*Clone) (AIMeshVertexIterator vertex, AIMeshVertexIterator* clone);
01044 
01051         AIAPI AIBoolean (*IsEqual) (AIMeshVertexIterator vertex1, AIMeshVertexIterator vertex2);
01052 
01062         AIAPI AIBoolean (*AtEnd) (AIMeshVertexIterator vertex);
01063 
01073         AIAPI void (*Next) (AIMeshVertexIterator vertex);
01074 
01081         AIAPI void (*Prev) (AIMeshVertexIterator vertex);
01082 
01089         AIAPI void (*NextI) (AIMeshVertexIterator vertex);
01090 
01097         AIAPI void (*PrevI) (AIMeshVertexIterator vertex);
01098 
01105         AIAPI void (*NextJ) (AIMeshVertexIterator vertex);
01106 
01113         AIAPI void (*PrevJ) (AIMeshVertexIterator vertex);
01114 
01120         AIAPI ai::int32 (*CountSegments) (AIMeshVertexIterator vertex);
01121 
01127         AIAPI AIBoolean (*IsNode) (AIMeshVertexIterator vertex);
01128 
01137         AIAPI ai::int32 (*GetSegmentIndex) (AIMeshVertexIterator vertex, ai::int32 axis, ai::int32 sense);
01138 
01146         AIAPI ai::int32 (*GetSegmentOpposite) (AIMeshVertexIterator vertex, ai::int32 i);
01147 
01152         AIAPI AIErr (*SetColor) (AIMeshVertexIterator vertex, AIColor* c);
01153 
01159         AIAPI void (*GetColor) (AIMeshVertexIterator vertex, AIColor* c);
01160 
01165         AIAPI AIErr (*SetPoint) (AIMeshVertexIterator vertex, AIRealPoint* point);
01166 
01172         AIAPI void (*GetPoint) (AIMeshVertexIterator vertex, AIRealPoint* point);
01173 
01180         AIAPI void (*GetUV) (AIMeshVertexIterator vertex, AIReal* u, AIReal* v);
01181 
01188         AIAPI AIErr (*SetTangent) (AIMeshVertexIterator vertex, ai::int32 i, AIRealPoint* point);
01189 
01197         AIAPI void (*GetTangent) (AIMeshVertexIterator vertex, ai::int32 i, AIRealPoint* point);
01198 
01206         AIAPI AIErr (*SetSmooth) (AIMeshVertexIterator vertex, ai::int32 i, AIBoolean smooth);
01207 
01216         AIAPI AIBoolean (*GetSmooth) (AIMeshVertexIterator vertex, ai::int32 i);
01217 
01224         AIAPI AIErr (*GetSegment) (AIMeshVertexIterator vertex, ai::int32 i, AIMeshSegmentIterator* segment);
01225 
01232         AIAPI AIErr (*GetPatch) (AIMeshVertexIterator vertex, ai::int32 i, AIMeshPatchIterator* patch);
01233 
01239         AIAPI AIBoolean (*IsOnBoundary) (AIMeshVertexIterator vertex);
01240 
01245         AIAPI AIErr (*SetOpacity) (AIMeshVertexIterator vertex, AIReal o);
01246 
01252         AIAPI void (*GetOpacity) (AIMeshVertexIterator vertex, AIReal* o);
01253 
01254 } AIMeshVertexIteratorSuite;
01255 
01256 
01267 typedef struct {
01268 
01276         AIAPI ai::int32 (*AddRef) (AIMeshSegmentIterator segment);
01277 
01284         AIAPI ai::int32 (*Release) (AIMeshSegmentIterator segment);
01285 
01290         AIAPI AIErr (*Copy) (AIMeshSegmentIterator segment, AIMeshSegmentIterator from);
01291 
01296         AIAPI AIErr (*Clone) (AIMeshSegmentIterator segment, AIMeshSegmentIterator* clone);
01297 
01305         AIAPI AIBoolean (*IsEqual) (AIMeshSegmentIterator segment1, AIMeshSegmentIterator segment2);
01306 
01316         AIAPI AIBoolean (*AtEnd) (AIMeshSegmentIterator segment);
01317 
01327         AIAPI void (*Next) (AIMeshSegmentIterator segment);
01328 
01335         AIAPI void (*Prev) (AIMeshSegmentIterator segment);
01336 
01344         AIAPI void (*NextOnAxis) (AIMeshSegmentIterator segment);
01345 
01353         AIAPI void (*PrevOnAxis) (AIMeshSegmentIterator segment);
01354 
01363         AIAPI void (*NextOnPatch) (AIMeshSegmentIterator segment, ai::int32 direction);
01364 
01373         AIAPI void (*PrevOnPatch) (AIMeshSegmentIterator segment, ai::int32 direction);
01374 
01379         AIAPI void (*Reverse) (AIMeshSegmentIterator segment);
01380 
01387         AIAPI ai::int32 (*CountKnots) (AIMeshSegmentIterator segment);
01388 
01398         AIAPI void (*GetKnotUV) (AIMeshSegmentIterator segment, ai::int32 n, AIReal* u, AIReal* v);
01399 
01406         AIAPI AIErr (*InsertKnots) (AIMeshSegmentIterator segment, ai::int32 m, ai::int32 n);
01407 
01414         AIAPI AIErr (*DeleteKnots) (AIMeshSegmentIterator segment, ai::int32 m, ai::int32 n);
01415 
01422         AIAPI ai::int32 (*CountPoints) (AIMeshSegmentIterator segment);
01423 
01429         AIAPI AIErr (*SetPoint) (AIMeshSegmentIterator segment, ai::int32 i, AIRealPoint* point);
01430 
01437         AIAPI void (*GetPoint) (AIMeshSegmentIterator segment, ai::int32 i, AIRealPoint* point);
01438 
01443         AIAPI AIErr (*GetStart) (AIMeshSegmentIterator segment, AIMeshVertexIterator* vertex);
01444 
01449         AIAPI AIErr (*GetEnd) (AIMeshSegmentIterator segment, AIMeshVertexIterator* vertex);
01450 
01457         AIAPI AIErr (*Split) (AIMeshSegmentIterator segment, ai::int32 n);
01458 
01465         AIAPI AIErr (*Join) (AIMeshSegmentIterator segment, ai::int32* n);
01466 
01473         AIAPI void (*GetControl) (AIMeshSegmentIterator segment, AIRealPoint* control);
01474 
01480         AIAPI AIErr (*Reshape) (AIMeshSegmentIterator segment, AIRealPoint* point, AIRealPoint* control);
01481 
01487         AIAPI AIBoolean (*IsOnBoundary) (AIMeshSegmentIterator segment);
01488 
01489 } AIMeshSegmentIteratorSuite;
01490 
01491 
01492 #include "AIHeaderEnd.h"
01493 
01494 
01495 #endif