#include <MeshVS_Buffer.hxx>
#include <gp_Pnt.hxx>
-#include <Image_ColorImage.hxx>
-#include <AlienImage_AlienImage.hxx>
-#include <AlienImage_BMPAlienImage.hxx>
+#include <Image_PixMap.hxx>
#include <Graphic3d_Texture2D.hxx>
#include <Graphic3d_TypeOfTextureMode.hxx>
#include <Standard_DefineHandle.hxx>
class MeshVS_ImageTexture2D : public Graphic3d_Texture2D
{
public:
- MeshVS_ImageTexture2D( Handle(Graphic3d_StructureManager) theSM,
- const Handle(AlienImage_AlienImage)& theImg );
+ MeshVS_ImageTexture2D (Handle(Graphic3d_StructureManager) theSM,
+ const Image_PixMap& theImg);
virtual ~MeshVS_ImageTexture2D();
public:
DEFINE_STANDARD_RTTI(MeshVS_ImageTexture2D)
};
-DEFINE_STANDARD_HANDLE(MeshVS_ImageTexture2D,Graphic3d_Texture2D)
-IMPLEMENT_STANDARD_HANDLE(MeshVS_ImageTexture2D,Graphic3d_Texture2D)
+DEFINE_STANDARD_HANDLE (MeshVS_ImageTexture2D, Graphic3d_Texture2D)
+IMPLEMENT_STANDARD_HANDLE (MeshVS_ImageTexture2D, Graphic3d_Texture2D)
IMPLEMENT_STANDARD_RTTIEXT(MeshVS_ImageTexture2D, Graphic3d_Texture2D)
-MeshVS_ImageTexture2D::MeshVS_ImageTexture2D
- (Handle(Graphic3d_StructureManager) theSM,
- const Handle(AlienImage_AlienImage)& theImg)
-: Graphic3d_Texture2D( theSM, "", Graphic3d_TOT_2D )
+MeshVS_ImageTexture2D::MeshVS_ImageTexture2D (Handle(Graphic3d_StructureManager) theSM,
+ const Image_PixMap& theImg)
+: Graphic3d_Texture2D (theSM, "", Graphic3d_TOT_2D)
{
MyCInitTexture.doModulate = 1;
MyCInitTexture.doRepeat = 0;
//================================================================
// Function : getNearestPow2
-// Purpose : Returns the nearest power of two greater than the
+// Purpose : Returns the nearest power of two greater than the
// argument value
//================================================================
static inline Standard_Integer getNearestPow2( Standard_Integer theValue )
/*
Class : MeshVS_NodalColorPrsBuilder
- Description : This class provides methods to create presentation of
+ Description : This class provides methods to create presentation of
nodes with assigned color (See hxx for more description )
*/
const Standard_Integer Id,
const MeshVS_BuilderPriority& Priority )
: MeshVS_PrsBuilder ( Parent, Flags, DS, Id, Priority ),
- myUseTexture( Standard_False ),
+ myUseTexture( Standard_False ),
myInvalidColor( Quantity_NOC_GRAY )
{
SetExcluding ( Standard_True );
if ( !( DisplayMode & GetFlags() ) || !IsElement )
return;
- if ( myUseTexture && ( !myTextureCoords.Extent() || !myTextureColorMap.Length() ) ||
+ if ( myUseTexture && ( !myTextureCoords.Extent() || !myTextureColorMap.Length() ) ||
!myUseTexture && !myNodeColorMap.Extent() )
return;
Standard_Boolean IsReflect = Standard_False, IsMeshSmoothShading = Standard_False;
aDrawer->GetBoolean( MeshVS_DA_ColorReflection, IsReflect );
aDrawer->GetBoolean( MeshVS_DA_SmoothShading, IsMeshSmoothShading );
-
+
// Following parameter are used for texture presentation only
int nbColors = 0; // Number of colors from color map
int nbTextureColors = 0; // Number of colors in texture (it will be pow of 2)
nbColors = myTextureColorMap.Length();
nbTextureColors = getNearestPow2( nbColors );
}
-
+
Standard_Integer aSize = anIDs.Extent();
// Calculate maximum possible number of vertices and bounds
// Draw faces with nodal color
// OCC20644 Use "plastic" material as it is "non-physic" and so it is easier
// to get the required colors (see TelUpdateMaterial() function in OpenGl_attri.c)
- Graphic3d_MaterialAspect aMaterial[ 2 ];
+ Graphic3d_MaterialAspect aMaterial[ 2 ];
aMaterial[ 0 ] = Graphic3d_MaterialAspect( Graphic3d_NOM_PLASTIC );
aMaterial[ 1 ] = Graphic3d_MaterialAspect( Graphic3d_NOM_PLASTIC );
Standard_Integer i;
aMaterial[i].SetSpecular( 0. );
aMaterial[i].SetEmissive( 0. );
}
-
- }
+
+ }
// Create array of polygons for interior presentation of faces and volumes
Handle(Graphic3d_ArrayOfPolygons) aCPolyArr = new Graphic3d_ArrayOfPolygons
- ( aMaxFaceNodes * aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D,
+ ( aMaxFaceNodes * aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D,
0, myUseTexture || IsReflect, !myUseTexture, Standard_False, myUseTexture );
- // Create array of polylines for presentation of edges
- // (used for optimization insted of SetEdgeOn method call)
+ // Create array of polylines for presentation of edges
+ // (used for optimization insted of SetEdgeOn method call)
Handle(Graphic3d_ArrayOfPolylines) aPolyL = new Graphic3d_ArrayOfPolylines
( ( aMaxFaceNodes + 1 ) * aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D );
// Preparing normal(s) to show reflections if requested
Handle(TColStd_HArray1OfReal) aNormals;
- Standard_Boolean hasNormals =
+ Standard_Boolean hasNormals =
( IsReflect && aSource->GetNormalsByElement( aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals ) );
if ( aType == MeshVS_ET_Face )
int anId = aNodes( i );
double aTexCoord = myTextureCoords( anId );
- // transform texture coordinate in accordance with number of colors specified
+ // transform texture coordinate in accordance with number of colors specified
// by upper level and real size of Gl texture
// The Gl texture has border colors interpolated with the colors from the color map,
- // thats why we need to shrink texture coordinates around the middle point to
+ // thats why we need to shrink texture coordinates around the middle point to
// exclude areas where the map colors are interpolated with the borders color
double aWrapCoord = 1.0 / (2.0 * nbTextureColors) + aTexCoord * (nbColors - 1.0) / nbTextureColors;
if ( hasNormals )
{
- gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
- aNormals->Value( 3 * i - 1 ),
+ gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
+ aNormals->Value( 3 * i - 1 ),
aNormals->Value( 3 * i ));
// There are two "rows" of colors: user's invalid color at the top
// of texture and line of map colors at the bottom of the texture.
// Since the texture has borders, which are interpolated with the "rows" of colors
// we should specify the 0.25 offset to get the correct texture color
aNorm.SquareMagnitude() > aMin ?
- aCPolyArr->AddVertex(P, gp_Dir( aNorm ),
- gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) ) :
- aCPolyArr->AddVertex(P, aDefNorm,
+ aCPolyArr->AddVertex(P, gp_Dir( aNorm ),
+ gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) ) :
+ aCPolyArr->AddVertex(P, aDefNorm,
gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
}
else
- aCPolyArr->AddVertex( P, aDefNorm,
+ aCPolyArr->AddVertex( P, aDefNorm,
gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
}
else
{
GetColor ( aNodes( i ), aNColor );
-
+
if ( IsReflect )
- {
+ {
// Simulating TelUpdateMaterial() from OpenGl_attri.c
// to get the same colors in elemental and nodal color prs builders
aNColor.SetValues(anColorRatio * aNColor.Red(),
anColorRatio * aNColor.Green(),
- anColorRatio * aNColor.Blue(),
+ anColorRatio * aNColor.Blue(),
Quantity_TOC_RGB);
-
+
if ( hasNormals )
{
- gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
- aNormals->Value( 3 * i - 1 ),
+ gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
+ aNormals->Value( 3 * i - 1 ),
aNormals->Value( 3 * i ));
aNorm.SquareMagnitude() > aMin ?
- aCPolyArr->AddVertex(P, gp_Dir( aNorm ), aNColor ) :
+ aCPolyArr->AddVertex(P, gp_Dir( aNorm ), aNColor ) :
aCPolyArr->AddVertex(P, aDefNorm , aNColor );
}
else
if ( !aSource->Get3DGeom( aKey, NbNodes, aTopo ) )
continue;
- // iterate through faces of volume
+ // iterate through faces of volume
for ( Standard_Integer k = aTopo->Lower(), last = aTopo->Upper(), normIndex = 1; k <= last; k++, normIndex++ )
{
const TColStd_SequenceOfInteger& aSeq = aTopo->Value( k );
for ( Standard_Integer j = 1; j <= m; j++ )
{
ind = aSeq.Value( j );
- P = gp_Pnt( aCoords( 3 * ind + 1 ),
- aCoords( 3 * ind + 2 ),
+ P = gp_Pnt( aCoords( 3 * ind + 1 ),
+ aCoords( 3 * ind + 2 ),
aCoords( 3 * ind + 3 ) );
if ( myUseTexture )
{
Standard_Integer anId = aNodes( ind + 1 );
Standard_Real aTexCoord = myTextureCoords( anId );
- // transform texture coordinate in accordance with number of colors specified
+ // transform texture coordinate in accordance with number of colors specified
// by upper level and real size of Gl texture
// The Gl texture has border colors interpolated with the colors from the color map,
- // thats why we need to shrink texture coordinates around the middle point to
+ // thats why we need to shrink texture coordinates around the middle point to
// exclude areas where the map colors are interpolated with the borders color
double aWrapCoord = 1.0 / (2.0 * nbTextureColors) + aTexCoord * (nbColors - 1.0) / nbTextureColors;
if ( hasNormals )
{
- gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
- aNormals->Value( 3 * i - 1 ),
+ gp_Vec aNorm(aNormals->Value( 3 * i - 2 ),
+ aNormals->Value( 3 * i - 1 ),
aNormals->Value( 3 * i ));
// There are two "rows" of colors: user's invalid color at the top
// of texture and line of map colors at the bottom of the texture.
// Since the texture has borders, which are interpolated with the "rows" of colors
// we should specify the 0.25 offset to get the correct texture color
aNorm.SquareMagnitude() > aMin ?
- aCPolyArr->AddVertex(P, gp_Dir( aNorm ),
- gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) ) :
- aCPolyArr->AddVertex(P, aDefNorm,
+ aCPolyArr->AddVertex(P, gp_Dir( aNorm ),
+ gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) ) :
+ aCPolyArr->AddVertex(P, aDefNorm,
gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
}
else
- aCPolyArr->AddVertex( P, aDefNorm,
+ aCPolyArr->AddVertex( P, aDefNorm,
gp_Pnt2d( aWrapCoord, aTexCoord >= 0 && aTexCoord <= 1 ? 0.75 : 0.25 ) );
}
else
{
GetColor( aNodes( ind + 1 ), aNColor );
if ( IsReflect )
- {
+ {
// Simulating TelUpdateMaterial() from OpenGl_attri.c
// to get the same colors in elemental and nodal color prs builders
aNColor.SetValues(anColorRatio * aNColor.Red(),
anColorRatio * aNColor.Green(),
- anColorRatio * aNColor.Blue(),
+ anColorRatio * aNColor.Blue(),
Quantity_TOC_RGB);
-
+
if ( hasNormals )
{
- gp_Vec aNorm(aNormals->Value( 3 * normIndex - 2 ),
- aNormals->Value( 3 * normIndex - 1 ),
+ gp_Vec aNorm(aNormals->Value( 3 * normIndex - 2 ),
+ aNormals->Value( 3 * normIndex - 1 ),
aNormals->Value( 3 * normIndex ));
- aNorm.SquareMagnitude() > aMin ?
- aCPolyArr->AddVertex( P, gp_Dir( aNorm ), aNColor ) :
+ aNorm.SquareMagnitude() > aMin ?
+ aCPolyArr->AddVertex( P, gp_Dir( aNorm ), aNColor ) :
aCPolyArr->AddVertex( P, aDefNorm , aNColor );
}
else
// if IsExcludingOn then presentation must not be built by other builders
if ( IsExcludingOn() )
IDsToExclude.Add( aKey );
- }
- }
+ }
+ }
} // for ( ...
Handle(Graphic3d_AspectFillArea3d) anAsp;
Handle(AIS_Drawer) anAISDrawer = myParentMesh->Attributes();
if ( anAISDrawer.IsNull() )
return;
-
+
anAISDrawer->SetShadingAspect( new Prs3d_ShadingAspect() );
anAsp = anAISDrawer->ShadingAspect()->Aspect();
if ( anAsp.IsNull() )
anAsp->SetFrontMaterial( aMaterial[ 0 ] );
anAsp->SetBackMaterial( aMaterial[ 1 ] );
-
+
Handle(Graphic3d_Texture2D) aTexture = CreateTexture();
if ( aTexture.IsNull() )
return;
- anAsp->SetTextureMapOn();
+ anAsp->SetTextureMapOn();
anAsp->SetTextureMap( aTexture );
anAsp->SetInteriorColor( Quantity_NOC_WHITE );
}
// if ( aDrawer->GetInteger ( MeshVS_DA_InteriorStyle, aStyleInt ) )
// aStyle = (Aspect_InteriorStyle)aStyleInt;
- anAsp = new Graphic3d_AspectFillArea3d (
+ anAsp = new Graphic3d_AspectFillArea3d (
Aspect_IS_SOLID, Quantity_NOC_GRAY, anEdgeColor,
anEdgeType, anEdgeWidth, aMaterial[ 0 ], aMaterial[ 1 ] );
}
anAsp->SetDistinguishOff();
anAsp->SetEdgeOff();
- Handle(Graphic3d_AspectLine3d) anLAsp =
+ Handle(Graphic3d_AspectLine3d) anLAsp =
new Graphic3d_AspectLine3d( anEdgeColor, anEdgeType, anEdgeWidth );
-
+
Prs3d_Root::NewGroup ( Prs );
Handle(Graphic3d_Group) aGroup1 = Prs3d_Root::CurrentGroup ( Prs );
-
+
aGroup1->SetPrimitivesAspect( anAsp );
aGroup1->BeginPrimitives();
aGroup1->AddPrimitiveArray( aCPolyArr );
Handle(Graphic3d_Group) aGroup2 = Prs3d_Root::CurrentGroup ( Prs );
anAsp->SetEdgeOff();
- anAsp->SetTextureMapOff();
+ anAsp->SetTextureMapOff();
aGroup2->SetPrimitivesAspect( anAsp );
aGroup2->SetPrimitivesAspect( anLAsp );
aGroup2->BeginPrimitives();
// Function : SetColors
// Purpose :
//================================================================
-void MeshVS_NodalColorPrsBuilder::SetColors (
+void MeshVS_NodalColorPrsBuilder::SetColors (
const MeshVS_DataMapOfIntegerColor& theColorMap )
{
myNodeColorMap = theColorMap;
//================================================================
// Function : SetColorMap
-// Purpose : Set colors to be used for texrture presentation.
+// Purpose : Set colors to be used for texrture presentation.
// Generate texture in accordance with given parameters
//================================================================
void MeshVS_NodalColorPrsBuilder::SetColorMap( const Aspect_SequenceOfColor& theColors )
//================================================================
// Function : GetColorMap
-// Purpose : Return colors used for texrture presentation
+// Purpose : Return colors used for texrture presentation
//================================================================
const Aspect_SequenceOfColor& MeshVS_NodalColorPrsBuilder::GetColorMap() const
{
//================================================================
// Function : SetInvalidColor
-// Purpose : Set color representing invalid texture coordinate
+// Purpose : Set color representing invalid texture coordinate
// (laying outside range [0, 1])
//================================================================
-void MeshVS_NodalColorPrsBuilder::SetInvalidColor(
+void MeshVS_NodalColorPrsBuilder::SetInvalidColor(
const Quantity_Color& theInvalidColor )
{
myInvalidColor = theInvalidColor;
//================================================================
// Function : SetTextureCoords
-// Purpose : Specify correspondence between node IDs and texture
+// Purpose : Specify correspondence between node IDs and texture
// coordinates (range [0, 1])
//================================================================
-void MeshVS_NodalColorPrsBuilder::SetTextureCoords (
+void MeshVS_NodalColorPrsBuilder::SetTextureCoords (
const TColStd_DataMapOfIntegerReal& theMap )
{
myTextureCoords = theMap;
//================================================================
// Function : GetTextureCoords
-// Purpose : Get correspondence between node IDs and texture
-// coordinates (range [0, 1])
+// Purpose : Get correspondence between node IDs and texture
+// coordinates (range [0, 1])
//================================================================
const TColStd_DataMapOfIntegerReal& MeshVS_NodalColorPrsBuilder::GetTextureCoords() const
{
//================================================================
// Function : SetTextureCoord
-// Purpose : Specify correspondence between node ID and texture
-// coordinate (range [0, 1])
+// Purpose : Specify correspondence between node ID and texture
+// coordinate (range [0, 1])
//================================================================
void MeshVS_NodalColorPrsBuilder::SetTextureCoord( const Standard_Integer theID,
const Standard_Real theCoord )
//================================================================
// Function : GetTextureCoord
-// Purpose : Return correspondence between node IDs and texture
-// coordinate (range [0, 1])
+// Purpose : Return correspondence between node IDs and texture
+// coordinate (range [0, 1])
//================================================================
Standard_Real MeshVS_NodalColorPrsBuilder::GetTextureCoord( const Standard_Integer theID )
{
//================================================================
Handle(Graphic3d_Texture2D) MeshVS_NodalColorPrsBuilder::CreateTexture() const
{
- Handle(Graphic3d_Texture2D) aTexture;
-
- int nbColors = myTextureColorMap.Length();
- if ( nbColors == 0 )
- return aTexture;
+ const Standard_Integer aColorsNb = myTextureColorMap.Length();
+ if (aColorsNb == 0)
+ {
+ return NULL;
+ }
Handle(PrsMgr_PresentationManager3d) aPrsMgr = GetPresentationManager();
- if ( aPrsMgr.IsNull() )
- return aTexture;
+ if (aPrsMgr.IsNull())
+ {
+ return NULL;
+ }
- int nbTextureColors = getNearestPow2( nbColors );
+ // create and fill image with colors
+ Image_PixMap anImage;
+ if (!anImage.InitTrash (Image_PixMap::ImgRGBA, Standard_Size(getNearestPow2 (aColorsNb)), 2))
+ {
+ return NULL;
+ }
- // Create and fill image with colors
- Handle(Image_ColorImage) aCImage =
- new Image_ColorImage( 0, 0, nbTextureColors, 2 );
+ anImage.SetTopDown (false);
+ Image_PixMapData<Image_ColorRGBA>& aData = anImage.EditData<Image_ColorRGBA>();
+ for (Standard_Size aCol = 0; aCol < Standard_Size(aColorsNb); ++aCol)
+ {
+ const Quantity_Color& aSrcColor = myTextureColorMap.Value (Standard_Integer(aCol) + 1);
+ Image_ColorRGBA& aColor = aData.ChangeValue (0, aCol);
+ aColor.r() = int(255.0 * aSrcColor.Red());
+ aColor.g() = int(255.0 * aSrcColor.Green());
+ aColor.b() = int(255.0 * aSrcColor.Blue());
+ aColor.a() = 0xFF;
+ }
- if ( nbColors > 0 )
+ // fill padding bytes
+ const Quantity_Color& aLastColorSrc = myTextureColorMap.Last();
+ const Image_ColorRGBA aLastColor =
+ {{
+ int(255.0 * aLastColorSrc.Red()),
+ int(255.0 * aLastColorSrc.Green()),
+ int(255.0 * aLastColorSrc.Blue()),
+ 0xFF
+ }};
+
+ // fill second row
+ for (Standard_Size aCol = (Standard_Size )aColorsNb; aCol < anImage.SizeX(); ++aCol)
{
- int i;
- for ( i = 0; i < nbColors; i++ )
- {
- aCImage->SetPixel( i, 0, Aspect_ColorPixel( myTextureColorMap( i + 1 ) ) );
- aCImage->SetPixel( i, 1, Aspect_ColorPixel( myInvalidColor ) );
- }
- Quantity_Color aLastColor = myTextureColorMap( nbColors );
- for ( i = nbColors; i < nbTextureColors; i++ )
- {
- aCImage->SetPixel( i, 0, aLastColor );
- aCImage->SetPixel( i, 1, Aspect_ColorPixel( myInvalidColor ) );
- }
+ aData.ChangeValue (0, aCol) = aLastColor;
}
- // Convert image to bmp
- Handle(AlienImage_BMPAlienImage) aTextureImage = new AlienImage_BMPAlienImage();
- aTextureImage->FromImage( aCImage );
+ const Image_ColorRGBA anInvalidColor =
+ {{
+ int(255.0 * myInvalidColor.Red()),
+ int(255.0 * myInvalidColor.Green()),
+ int(255.0 * myInvalidColor.Blue()),
+ 0xFF
+ }};
+ for (Standard_Size aCol = 0; aCol < anImage.SizeX(); ++aCol)
+ {
+ aData.ChangeValue (1, aCol) = anInvalidColor;
+ }
- // Create texture
- aTexture = new MeshVS_ImageTexture2D( aPrsMgr->StructureManager(), aTextureImage );
- return aTexture;
+ // create texture
+ return new MeshVS_ImageTexture2D (aPrsMgr->StructureManager(), anImage);
}