src/Graphic3d/Graphic3d_ArrayOfPrimitives.cdl

   1 -- Created on: 2000-06-16
   2 -- Copyright (c) 2000-2012 OPEN CASCADE SAS
   3 --
   4 -- The content of this file is subject to the Open CASCADE Technology Public
   5 -- License Version 6.5 (the "License"). You may not use the content of this file
   6 -- except in compliance with the License. Please obtain a copy of the License
   7 -- at http://www.opencascade.org and read it completely before using this file.
   8 --
   9 -- The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  10 -- main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  11 --
  12 -- The Original Code and all software distributed under the License is
  13 -- distributed on an "AS IS" basis, without warranty of any kind, and the
  14 -- Initial Developer hereby disclaims all such warranties, including without
  15 -- limitation, any warranties of merchantability, fitness for a particular
  16 -- purpose or non-infringement. Please see the License for the specific terms
  17 -- and conditions governing the rights and limitations under the License.
  18
  19
  20 deferred class ArrayOfPrimitives from Graphic3d inherits TShared
  21
  22         ---Purpose: This class furnish services to defined and fill an
  23         --      array of primitives compatible with the use of
  24         --      the OPENGl glDrawArrays() or glDrawElements() functions.
  25         --      NOTE that the main goal of this kind of primitive
  26         --      is to avoid multiple copies of datas between
  27         --      each layer of the software.
  28         --      So the array datas exist only one time and the use
  29         --      of SetXxxxxx() methods enable to change dynamically
  30         --      the aspect of this primitive.
  31         --
  32         --      Advantages are :
  33         --      1) Decrease strongly the loading time.
  34         --      2) Decrease strongly the display time using optimized Opengl
  35         --         primitives.
  36         --      3) Enable to change dynamically the components of the primitive
  37         --         (vertice,normal,color,texture coordinates).
  38         --      4) Add true triangle and quadrangle strips or fans capabilities.
  39
  40 uses
  41
  42     TypeOfPrimitiveArray    from Graphic3d,
  43     PrimitiveArray      from Graphic3d,
  44     Color           from Quantity,
  45     Pnt         from gp,
  46     Pnt2d           from gp,
  47     Dir         from gp
  48
  49 raises
  50     OutOfRange from Standard,
  51     InitialisationError from Graphic3d
  52
  53 is
  54
  55     -- constructor
  56     Initialize (
  57         aType: TypeOfPrimitiveArray from Graphic3d;
  58                 maxVertexs: Integer from Standard;
  59                 maxBounds: Integer from Standard;
  60                 maxEdges: Integer from Standard;
  61                 hasVNormals: Boolean from Standard;
  62                 hasVColors: Boolean from Standard;
  63                 hasBColors: Boolean from Standard;
  64                 hasTexels: Boolean from Standard;
  65             hasEdgeInfos: Boolean from Standard)
  66     returns mutable ArrayOfPrimitives from Graphic3d
  67         raises  InitialisationError from Graphic3d;
  68     ---Purpose:  Warning
  69     -- You must use a coherent set of AddVertex() methods according to the
  70     -- <hasVNormals>,<hasVColors>,<hasVTexels>,<hasBColors>
  71     -- User is responsible of confuse vertex and bad normal orientation.
  72     -- You must use AddBound() method only if the <maxBounds>
  73     -- constructor parameter is > 0.
  74     -- You must use AddEdge() method only if the <maxEdges>
  75     -- constructor parameter is > 0.
  76     -- You must use a coherent set of AddEdge() methods according to the
  77     -- <hasEdgeInfos> constructor parameter.
  78
  79     Destroy( me: mutable);
  80     -- destructor
  81     ---C++: alias ~
  82
  83     -- -------------------------------------------------------------------
  84     --      Methods to fill array
  85     -- -------------------------------------------------------------------
  86
  87     AddVertex( me:mutable;
  88                aVertice: Pnt from gp)
  89     returns Integer from Standard
  90     ---Level: Public
  91     ---Purpose: Adds a vertice in the array.
  92     -- returns the actual vertex number.
  93     raises OutOfRange from Standard;
  94     -- if the actual vertex number is >= <maxVertexs>
  95     ---C++: inline
  96
  97     AddVertex( me:mutable;
  98                X,Y,Z: Real from Standard)
  99     returns Integer from Standard
 100     ---Level: Public
 101     ---Purpose: Adds a vertice in the array.
 102     -- returns the actual vertex number.
 103     raises OutOfRange from Standard;
 104     -- if the actual vertex number is >= <maxVertexs>
 105     ---C++: inline
 106
 107     AddVertex( me:mutable;
 108                X,Y,Z: ShortReal from Standard)
 109     returns Integer from Standard
 110     ---Level: Public
 111     ---Purpose: Adds a vertice in the array.
 112     -- returns the actual vertex number.
 113     raises OutOfRange from Standard;
 114     -- if the actual vertex number is >= <maxVertexs>
 115
 116     AddVertex( me:mutable;
 117                aVertice: Pnt from gp;
 118                aColor: Color from Quantity)
 119         returns Integer from Standard
 120         ---Level: Public
 121     ---Purpose: Adds a vertice and vertex color in the vertex array.
 122     -- returns the actual vertex number.
 123     --  Warning: <aColor> is ignored when the <hasVColors>
 124     -- constructor parameter is FALSE
 125         raises OutOfRange from Standard;
 126     -- if the actual vertex number is >= <maxVertexs>
 127
 128     AddVertex( me       : mutable;
 129                aVertice : Pnt from gp;
 130                aColor   : Integer from Standard)
 131     returns Integer from Standard
 132     ---Level: Public
 133     ---Purpose: Adds a vertice and vertex color in the vertex array.
 134     -- returns the actual vertex number.
 135     -- Warning: <aColor> is ignored when the <hasVColors>
 136     -- constructor parameter is FALSE
 137     -- aColor = Alpha << 24 + Blue << 16 + Green << 8 + Red
 138     -- On all architecture proccers type (x86 or SPARC) you can
 139     -- use this byte order.
 140         raises OutOfRange from Standard;
 141     -- if the actual vertex number is >= <maxVertexs>
 142
 143     AddVertex( me       :mutable;
 144                aVertice : Pnt from gp;
 145                aNormal  : Dir from gp)
 146     returns Integer from Standard
 147     ---Level: Public
 148     ---Purpose: Adds a vertice and vertex normal in the vertex array.
 149     -- returns the actual vertex number.
 150     --  Warning: <aNormal> is ignored when the <hasVNormals>
 151     -- constructor parameter is FALSE.
 152         raises OutOfRange from Standard;
 153     -- if the actual vertex number is >= <maxVertexs>
 154     ---C++: inline
 155
 156     AddVertex( me:mutable;
 157                X,Y,Z: Real from Standard;
 158                NX,NY,NZ: Real from Standard)
 159     returns Integer from Standard
 160     ---Level: Public
 161     ---Purpose: Adds a vertice and vertex normal in the vertex array.
 162     -- returns the actual vertex number.
 163     --  Warning: <aNormal> is ignored when the <hasVNormals>
 164     -- constructor parameter is FALSE.
 165         raises OutOfRange from Standard;
 166     -- if the actual vertex number is >= <maxVertexs>
 167     ---C++: inline
 168
 169     AddVertex( me:mutable;
 170                X,Y,Z: ShortReal from Standard;
 171                NX,NY,NZ: ShortReal from Standard)
 172     returns Integer from Standard
 173     ---Level: Public
 174     ---Purpose: Adds a vertice and vertex normal in the vertex array.
 175     -- returns the actual vertex number.
 176     --  Warning: <aNormal> is ignored when the <hasVNormals>
 177     -- constructor parameter is FALSE.
 178         raises OutOfRange from Standard;
 179     -- if the actual vertex number is >= <maxVertexs>
 180
 181     AddVertex( me:mutable;
 182                aVertice: Pnt from gp;
 183                aNormal: Dir from gp;
 184                aColor: Color from Quantity)
 185     returns Integer from Standard
 186     ---Level: Public
 187     ---Purpose: Adds a vertice,vertex normal and color in the vertex array.
 188     -- returns the actual vertex number.
 189     --  Warning: <aNormal> is ignored when the <hasVNormals>
 190     -- constructor parameter is FALSE.
 191     --          <aColor> is ignored when the <hasVColors>
 192     -- constructor parameter is FALSE
 193         raises OutOfRange from Standard;
 194     -- if the actual vertex number is >= <maxVertexs>
 195
 196     AddVertex( me       : mutable;
 197                aVertice : Pnt from gp;
 198                aNormal  : Dir from gp;
 199                aColor   : Integer from Standard)
 200     returns Integer from Standard
 201     ---Level: Public
 202     ---Purpose: Adds a vertice,vertex normal and color in the vertex array.
 203     -- returns the actual vertex number.
 204     --  Warning: <aNormal> is ignored when the <hasVNormals>
 205     -- constructor parameter is FALSE.
 206     --          <aColor> is ignored when the <hasVColors>
 207     -- constructor parameter is FALSE
 208     -- aColor = Alpha << 24 + Blue << 16 + Green << 8 + Red
 209     -- On all architecture proccers type (x86 or SPARC) you can
 210     -- use this byte order.
 211         raises OutOfRange from Standard;
 212     -- if the actual vertex number is >= <maxVertexs>
 213
 214     AddVertex( me:mutable;
 215                aVertice: Pnt from gp;
 216                aTexel: Pnt2d from gp)
 217     returns Integer from Standard
 218     ---Level: Public
 219     ---Purpose: Adds a vertice and vertex texture in the vertex array.
 220     -- returns the actual vertex number.
 221     -- <aTexel> is ignored when the <hasVTexels>
 222     -- constructor parameter is FALSE.
 223         raises OutOfRange from Standard;
 224     -- if the actual vertex number is >= <maxVertexs>
 225     ---C++: inline
 226
 227     AddVertex( me:mutable;
 228                X,Y,Z: Real from Standard;
 229                TX,TY: Real from Standard)
 230     returns Integer from Standard
 231     ---Level: Public
 232     ---Purpose: Adds a vertice and vertex texture coordinates in the vertex array.
 233     -- returns the actual vertex number.
 234     -- <aTexel> is ignored when the <hasVTexels>
 235     -- constructor parameter is FALSE.
 236         raises OutOfRange from Standard;
 237     -- if the actual vertex number is >= <maxVertexs>
 238     ---C++: inline
 239
 240     AddVertex( me:mutable;
 241                X,Y,Z: ShortReal from Standard;
 242                TX,TY: ShortReal from Standard)
 243     returns Integer from Standard
 244     ---Level: Public
 245     ---Purpose: Adds a vertice and vertex texture coordinates in the vertex array.
 246     -- returns the actual vertex number.
 247     -- <aTexel> is ignored when the <hasVTexels>
 248     -- constructor parameter is FALSE.
 249         raises OutOfRange from Standard;
 250     -- if the actual vertex number is >= <maxVertexs>
 251
 252     AddVertex( me:mutable;
 253                aVertice: Pnt from gp;
 254                aNormal: Dir from gp;
 255                aTexel: Pnt2d from gp)
 256     returns Integer from Standard
 257     ---Level: Public
 258     ---Purpose: Adds a vertice,vertex normal and texture in the vertex array.
 259     -- returns the actual vertex number.
 260     --  Warning: <aNormal> is ignored when the <hasVNormals>
 261     -- constructor parameter is FALSE.
 262     -- <aTexel> is ignored when the <hasVTexels>
 263     -- constructor parameter is FALSE.
 264         raises OutOfRange from Standard;
 265     -- if the actual vertex number is >= <maxVertexs>
 266     ---C++: inline
 267
 268     AddVertex( me:mutable;
 269                X,Y,Z: Real from Standard;
 270                NX,NY,NZ: Real from Standard;
 271                TX,TY: Real from Standard)
 272     returns Integer from Standard
 273     ---Level: Public
 274     ---Purpose: Adds a vertice,vertex normal and texture in the vertex array.
 275     -- returns the actual vertex number.
 276     --  Warning: <aNormal> is ignored when the <hasVNormals>
 277     -- constructor parameter is FALSE.
 278     -- <aTexel> is ignored when the <hasVTexels>
 279     -- constructor parameter is FALSE.
 280         raises OutOfRange from Standard;
 281     -- if the actual vertex number is >= <maxVertexs>
 282     ---C++: inline
 283
 284     AddVertex( me:mutable;
 285                X,Y,Z: ShortReal from Standard;
 286                NX,NY,NZ: ShortReal from Standard;
 287                TX,TY: ShortReal from Standard)
 288     returns Integer from Standard
 289     ---Level: Public
 290     ---Purpose: Adds a vertice,vertex normal and texture in the vertex array.
 291     -- returns the actual vertex number.
 292     --  Warning: <aNormal> is ignored when the <hasVNormals>
 293     -- constructor parameter is FALSE.
 294     -- <aTexel> is ignored when the <hasVTexels>
 295     -- constructor parameter is FALSE.
 296         raises OutOfRange from Standard;
 297     -- if the actual vertex number is >= <maxVertexs>
 298
 299     AddBound( me:mutable;
 300                edgeNumber: Integer from Standard)
 301         returns Integer from Standard
 302         ---Level: Public
 303     ---Purpose: Adds a bound of length <edgeNumber> in the bound array
 304     -- returns the actual bounds number.
 305         raises OutOfRange from Standard;
 306     -- if the actual Bound number is >= <maxBounds>
 307
 308     AddBound( me:mutable;
 309               edgeNumber: Integer from Standard;
 310               aBColor: Color from Quantity)
 311         returns Integer from Standard
 312         ---Level: Public
 313     ---Purpose: Adds a bound of length <edgeNumber> and bound color
 314     -- <aBColor> in the bound array.
 315     -- returns the actual bounds number.
 316     --  Warning: <aBColor> is ignored when the <hasBColors>
 317     -- constructor parameter is FALSE
 318         raises OutOfRange from Standard;
 319     -- if the actual Bound number is >= <maxBounds>
 320
 321     AddBound( me:mutable;
 322                 edgeNumber: Integer from Standard;
 323                 R,G,B: Real from Standard)
 324         returns Integer from Standard
 325         ---Level: Public
 326     ---Purpose: Adds a bound of length <edgeNumber> and bound color
 327     -- coordinates in the bound array.
 328     -- returns the actual bounds number.
 329     --  Warning: <R,G,B> are ignored when the <hasBColors>
 330     -- constructor parameter is FALSE
 331         raises OutOfRange from Standard;
 332     -- if the actual Bound number is >= <maxBounds>
 333
 334     AddEdge( me:mutable;
 335          vertexIndex: Integer from Standard;
 336          isVisible: Boolean from Standard = Standard_True)
 337         returns Integer from Standard
 338         ---Level: Public
 339     ---Purpose: Adds an edge in the range [1,VertexNumber()] in the array,
 340     -- if <isVisible> is FALSE the edge between <vertexIndex> and
 341     -- the next edge will not be visible even if the SetEdgeOn() method
 342     -- is activated in Graphic3d_AspectFillArea3d class.
 343     -- returns the actual edges number.
 344     --  Warning: <isVisible> is ignored when the <hasEdgeInfos>
 345     -- constructor parameter is FALSE.
 346         raises OutOfRange from Standard;
 347     -- if the actual edge number is >= <maxEdges>
 348
 349     -- -------------------------------------------------------------------
 350     --      Methods to modify the array
 351     -- -------------------------------------------------------------------
 352
 353     Orientate( me:mutable;
 354         aNormal: Dir from gp)
 355     returns Boolean from Standard;
 356     ---Level: Public
 357     ---Purpose: Orientate correctly all vertexs & normals of this array
 358     -- according to the <aNormal> parameter and
 359     -- returns TRUE when something has change in the array.
 360     --  Warning: When the array has edges this method is apply
 361     -- on edge sub array instead on vertex sub array.
 362
 363     Orientate( me:mutable;
 364         aVertexIndex: Integer from Standard;
 365         aVertexNumber: Integer from Standard;
 366         aNormal: Dir from gp)
 367     returns Boolean from Standard
 368     ---Level: Internal
 369     ---Purpose: Orientate correctly a set of vertexs & normal
 370     -- from <aVertexIndex> to <aVertexIndex>+<aVertexNumber>-1
 371     -- according to the <aNormal> parameter and
 372     -- returns TRUE when something has change in the array.
 373     --  Warning: When the array has edges this method is apply
 374     -- on edge sub array instead on vertex sub array.
 375         raises OutOfRange from Standard is private;
 376     -- if the <aVertexIndex> parameter is < 1 or > VertexNumber() or
 377     -- EdgeNumber()
 378
 379     Orientate( me:mutable;
 380         aBoundIndex: Integer from Standard;
 381         aNormal: Dir from gp)
 382     returns Boolean from Standard
 383     ---Level: Public
 384     ---Purpose: Orientate correctly all vertexs & normal of the bound <aBound>
 385     -- according to the <aNormal> parameter and
 386     -- returns TRUE when something has change in the array.
 387     --  Warning: When the array has edges this method is apply
 388     -- on edge sub array instead on vertex sub array.
 389     -- When this array has no bound, <aBoundIndex> design the item number
 390         raises OutOfRange from Standard;
 391     -- if the <aBoundIndex> parameter is < 1 or > BoundNumber()
 392     -- or if the <aBoundIndex> parameter is < 1 or > ItemNumber()
 393
 394     SetVertice( me:mutable;
 395                 anIndex: Integer from Standard;
 396                 aVertice: Pnt from gp)
 397         ---Level: Public
 398         ---Purpose: Change the vertice of rank <anIndex> in the array.
 399         raises OutOfRange from Standard;
 400         -- if the index is <1 or > VertexNumber()
 401
 402     SetVertice( me:mutable;
 403                 anIndex: Integer from Standard;
 404                 X,Y,Z: ShortReal from Standard)
 405         ---Level: Public
 406         ---Purpose: Change the vertice of rank <anIndex> in the array.
 407         raises OutOfRange from Standard;
 408         -- if the index is <1 or > VertexNumber()
 409         ---C++: inline
 410
 411     SetVertexColor( me      : mutable;
 412                     anIndex : Integer from Standard;
 413                     aColor  : Color from Quantity)
 414         ---Level: Public
 415         ---Purpose: Change the vertex color of rank <anIndex> in the array.
 416         raises OutOfRange from Standard;
 417         -- if the index is <1 or > VertexNumber()
 418
 419     SetVertexColor( me      : mutable;
 420                     anIndex : Integer from Standard;
 421                     R,G,B   : Real from Standard)
 422         ---Level: Public
 423         ---Purpose: Change the vertex color of rank <anIndex> in the array.
 424         raises OutOfRange from Standard;
 425         -- if the index is <1 or > VertexNumber()
 426         ---C++: inline
 427
 428     SetVertexColor( me      : mutable;
 429                     anIndex : Integer from Standard;
 430                     aColor  : Integer from Standard)
 431         ---Level: Public
 432         ---Purpose: Change the vertex color of rank <anIndex> in the array.
 433         -- aColor = Alpha << 24 + Blue << 16 + Green << 8 + Red
 434         -- On all architecture proccers type (x86 or SPARC) you can
 435         -- use this byte order.
 436         raises OutOfRange from Standard;
 437         -- if the index is <1 or > VertexNumber()
 438
 439
 440     SetVertexNormal( me      : mutable;
 441                      anIndex : Integer from Standard;
 442                      aNormal : Dir from gp)
 443         ---Level: Public
 444         ---Purpose: Change the vertex normal of rank <anIndex> in the array.
 445         raises OutOfRange from Standard;
 446         -- if the index is <1 or > VertexNumber()
 447
 448     SetVertexNormal( me      : mutable;
 449                      anIndex : Integer from Standard;
 450                      NX,NY,NZ: Real from Standard)
 451         ---Level: Public
 452         ---Purpose: Change the vertex normal of rank <anIndex> in the array.
 453         raises OutOfRange from Standard;
 454         -- if the index is <1 or > VertexNumber()
 455         ---C++: inline
 456
 457     SetVertexTexel( me:mutable;
 458          anIndex: Integer from Standard;
 459                  aTexel: Pnt2d from gp)
 460         ---Level: Public
 461         ---Purpose: Change the vertex texel of rank <anIndex> in the array.
 462         raises OutOfRange from Standard;
 463         -- if the index is <1 or > VertexNumber()
 464
 465     SetVertexTexel( me:mutable;
 466          anIndex: Integer from Standard;
 467                  TX,TY: Real from Standard)
 468         ---Level: Public
 469         ---Purpose: Change the vertex texel of rank <anIndex> in the array.
 470         raises OutOfRange from Standard;
 471         -- if the index is <1 or > VertexNumber()
 472         ---C++: inline
 473
 474     SetBoundColor( me:mutable;
 475          anIndex: Integer from Standard;
 476                  aColor: Color from Quantity)
 477         ---Level: Public
 478         ---Purpose: Change the bound color of rank <anIndex> in the array.
 479         raises OutOfRange from Standard;
 480         -- if the index is <1 or > BoundNumber()
 481
 482     SetBoundColor( me:mutable;
 483          anIndex: Integer from Standard;
 484                  R,G,B: Real from Standard)
 485         ---Level: Public
 486         ---Purpose: Change the bound color of rank <anIndex> in the array.
 487         raises OutOfRange from Standard;
 488         -- if the index is <1 or > BoundNumber()
 489         ---C++: inline
 490
 491     -------------------------------------------------------------------
 492     -- Category Inquiries on array
 493     -------------------------------------------------------------------
 494
 495     Array( me )
 496     returns PrimitiveArray from Graphic3d;
 497     ---Level: Internal
 498     ---Purpose: Returns the array address.
 499     ---C++: inline
 500
 501     Type( me )
 502     returns TypeOfPrimitiveArray from Graphic3d;
 503     ---Level: Public
 504     ---Purpose: Returns the type of this primitive
 505     ---C++: inline
 506
 507     StringType( me )
 508     returns CString from Standard;
 509     ---Level: Public
 510     ---Purpose: Returns the string type of this primitive
 511
 512     HasVertexNormals( me )
 513     returns Boolean from Standard;
 514     ---Level: Public
 515     ---Purpose: Returns TRUE when vertex normals array is defined.
 516     ---C++: inline
 517
 518     HasVertexColors( me )
 519     returns Boolean from Standard;
 520     ---Level: Public
 521     ---Purpose: Returns TRUE when vertex colors array is defined.
 522     ---C++: inline
 523
 524     HasVertexTexels( me )
 525     returns Boolean from Standard;
 526     ---Level: Public
 527     ---Purpose: Returns TRUE when vertex texels array is defined.
 528     ---C++: inline
 529
 530     VertexNumber( me )
 531     returns Integer from Standard;
 532     ---Level: Public
 533     ---Purpose: Returns the number of defined vertex
 534     ---C++: inline
 535
 536     Vertice( me ; aRank: Integer from Standard)
 537     returns Pnt from gp
 538     ---Level: Public
 539     ---Purpose: Returns the vertice at rank <aRank>
 540     -- from the vertex table if defined.
 541     raises OutOfRange from Standard;
 542     -- when the rank is < 1 or > VertexNumber().
 543
 544     Vertice( me ; aRank: Integer from Standard;
 545         X,Y,Z: out Real from Standard)
 546     ---Level: Public
 547     ---Purpose: Returns the vertice coordinates at rank <aRank>
 548     -- from the vertex table if defined.
 549     raises OutOfRange from Standard;
 550     -- when the rank is < 1 or > VertexNumber().
 551     ---C++: inline
 552
 553     VertexColor( me ; aRank: Integer from Standard)
 554     returns Color from Quantity
 555     ---Level: Public
 556     ---Purpose: Returns the vertex color at rank <aRank>
 557     -- from the vertex table if defined.
 558     raises OutOfRange from Standard;
 559     -- when the rank is < 1 or > VertexNumber().
 560
 561     VertexColor( me ; aRank   : Integer from Standard;
 562                       R, G, B : out Real from Standard)
 563     ---Level: Public
 564     ---Purpose: Returns the vertex color values at rank <aRank>
 565     -- from the vertex table if defined.
 566     raises OutOfRange from Standard;
 567     -- when the rank is < 1 or > VertexNumber().
 568     ---C++: inline
 569
 570     VertexColor( me ; aRank: Integer from Standard;
 571                  aColor: out Integer from Standard)
 572     ---Level: Public
 573     ---Purpose: Returns the vertex color values at rank <aRank>
 574     -- from the vertex table if defined.
 575     raises OutOfRange from Standard;
 576     -- when the rank is < 1 or > VertexNumber().
 577     ---C++: inline
 578
 579
 580     VertexNormal( me ; aRank: Integer from Standard)
 581     returns Dir from gp
 582     ---Level: Public
 583     ---Purpose: Returns the vertex normal at rank <aRank>
 584     -- from the vertex table if defined.
 585     raises OutOfRange from Standard;
 586     -- when the rank is < 1 or > VertexNumber().
 587
 588     VertexNormal( me ; aRank: Integer from Standard;
 589         NX,NY,NZ: out Real from Standard)
 590     ---Level: Public
 591     ---Purpose: Returns the vertex normal coordinates at rank <aRank>
 592     -- from the vertex table if defined.
 593     raises OutOfRange from Standard;
 594     -- when the rank is < 1 or > VertexNumber().
 595     ---C++: inline
 596
 597     VertexTexel( me ; aRank: Integer from Standard)
 598     returns Pnt2d from gp
 599     ---Level: Public
 600     ---Purpose: Returns the vertex texture at rank <aRank>
 601     -- from the vertex table if defined.
 602     raises OutOfRange from Standard;
 603     -- when the rank is < 1 or > VertexNumber().
 604
 605     VertexTexel( me ; aRank: Integer from Standard;
 606         TX,TY: out Real from Standard)
 607     ---Level: Public
 608     ---Purpose: Returns the vertex texture coordinates at rank <aRank>
 609     -- from the vertex table if defined.
 610     raises OutOfRange from Standard;
 611     -- when the rank is < 1 or > VertexNumber().
 612     ---C++: inline
 613
 614     HasEdgeInfos( me )
 615     returns Boolean from Standard;
 616     ---Level: Public
 617     ---Purpose: Returns TRUE when edge visibillity array is defined.
 618     ---C++: inline
 619
 620     EdgeNumber( me )
 621     returns Integer from Standard;
 622     ---Level: Public
 623     ---Purpose: Returns the number of defined edges
 624     ---C++: inline
 625
 626     Edge( me ; aRank: Integer from Standard)
 627     returns Integer from Standard
 628     ---Level: Public
 629     ---Purpose: Returns the vertex index at rank <aRank>
 630     -- in the range [1,VertexNumber()]
 631     raises OutOfRange from Standard;
 632     -- when the rank is < 1 or > EdgeNumber()
 633     ---C++: inline
 634
 635     EdgeIsVisible( me ; aRank: Integer from Standard)
 636     returns Boolean from Standard
 637     ---Level: Public
 638     ---Purpose: Returns TRUE when the edge at rank <aRank>
 639     -- is visible.
 640     raises OutOfRange from Standard;
 641     -- when the rank is < 1 or > EdgeNumber()
 642     ---C++: inline
 643
 644     HasBoundColors( me )
 645     returns Boolean from Standard;
 646     ---Level: Public
 647     ---Purpose: Returns TRUE when bound colors array is defined.
 648     ---C++: inline
 649
 650     BoundNumber( me )
 651     returns Integer from Standard;
 652     ---Level: Public
 653     ---Purpose: Returns the number of defined bounds
 654     ---C++: inline
 655
 656     Bound( me ; aRank: Integer from Standard)
 657     returns Integer from Standard
 658     ---Level: Public
 659     ---Purpose: Returns the edge number at rank <aRank>.
 660     raises OutOfRange from Standard;
 661     -- when the rank is < 1 or > BoundNumber()
 662     ---C++: inline
 663
 664     BoundColor( me ; aRank: Integer from Standard)
 665     returns Color from Quantity
 666     ---Level: Public
 667     ---Purpose: Returns the bound color at rank <aRank>
 668     -- from the bound table if defined.
 669     raises OutOfRange from Standard;
 670     -- when the rank is < 1 or > BoundNumber()
 671
 672     BoundColor( me ; aRank: Integer from Standard;
 673             R,G,B: out Real from Standard)
 674     ---Level: Public
 675     ---Purpose: Returns the bound color values at rank <aRank>
 676     -- from the bound table if defined.
 677     raises OutOfRange from Standard;
 678     -- when the rank is < 1 or > BoundNumber()
 679
 680     ItemNumber( me )
 681     returns Integer from Standard;
 682     ---Level: Public
 683     ---Purpose: Returns the number of total items according to
 684     --  the array type.
 685
 686     -------------------------------------------------------------------
 687     -- Category Miscellaneous
 688     -------------------------------------------------------------------
 689
 690     IsValid( me:mutable )
 691     returns Boolean from Standard;
 692     ---Level: Public
 693     ---Purpose: Returns TRUE only when the contains of this array is
 694     -- available.
 695
 696     ComputeVNormals( me:mutable ; fromIndex,toIndex: Integer from Standard)
 697     is private;
 698
 699 fields
 700     myPrimitiveArray:   PrimitiveArray from Graphic3d;
 701     myMaxBounds:        Integer from Standard;
 702     myMaxVertexs:       Integer from Standard;
 703     myMaxEdges:     Integer from Standard;
 704
 705 friends
 706     class Group from Graphic3d
 707 end;