OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0022591: Migration to FreeImage: texture management

Browse Source 
Graphic3d_TextureRoot - migrate to Image_AlienPixMap
OpenGl_View::CreateBackgroundTexture() - migrate to Image_AlienPixMap
Fixed Graphic3d_TextureRoot::LoadTexture() method.
This commit is contained in:
kgv 2012-11-15 12:52:57 +04:00
parent 33a085531a
commit 3c3131a05d
9 changed files with 463 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/Graphic3d/Graphic3d_GraphicDriver.cdl
View File

@ -188,12 +188,6 @@ is
is deferred;
---Purpose: call_togl_inquireview
InquireTextureAvailable ( me : mutable )
returns Boolean from Standard
is deferred;
---Purpose: Returns Standard_True if texture is
-- supported by the graphic driver
------------------------------
-- Category: Highlight methods
------------------------------
@ -810,12 +804,12 @@ is
-- Category: Textures methods
-----------------------------
CreateTexture ( me;
Type : TypeOfTexture from Graphic3d;
Image : AlienImage from AlienImage;
FileName : CString from Standard;
TexUpperBounds : HArray1OfReal from TColStd )
returns Integer from Standard
CreateTexture ( me;
theType : TypeOfTexture from Graphic3d;
theImage : PixMap from Image;
theFileName : CString from Standard;
theTexUpperBounds : HArray1OfReal from TColStd )
returns Integer from Standard
is deferred;
---Purpose:

117
src/Graphic3d/Graphic3d_TextureRoot.cdl
View File

@ -18,106 +18,91 @@
-- purpose or non-infringement. Please see the License for the specific terms
-- and conditions governing the rights and limitations under the License.
-- Modified: GG 10/01/2000 IMP add Path() & Type() methods.
-- GG 10/11/2000 IMP add Image() & LoadTexture() methods.
-- Remove MyIsDone field
-- Add MyImage field
deferred class TextureRoot from Graphic3d
deferred class TextureRoot from Graphic3d
inherits TShared from MMgt
inherits TShared from MMgt
---Purpose: This is the texture root class enable the dialog with the GraphicDriver
-- allows the loading of texture too supported formats:
-- X, SunRaster, Aida, Euclid, SGI rgb
-- allows the loading of texture.
uses
CInitTexture from Graphic3d,
GraphicDriver from Graphic3d,
StructureManager from Graphic3d,
TypeOfTexture from Graphic3d,
AlienImage from AlienImage,
Path from OSD,
HArray1OfReal from TColStd
uses
CInitTexture from Graphic3d,
GraphicDriver from Graphic3d,
StructureManager from Graphic3d,
TypeOfTexture from Graphic3d,
PixMap from Image,
Path from OSD,
HArray1OfReal from TColStd
is
Initialize(SM : StructureManager from Graphic3d;
Path : CString from Standard;
FileName : CString from Standard;
Type : TypeOfTexture from Graphic3d);
is
Initialize (theSM : StructureManager from Graphic3d;
thePath : CString from Standard;
theFileName : CString from Standard;
theType : TypeOfTexture from Graphic3d);
---Purpose: Creates a texture from a file
-- Warning: Note that if <FileName> is NULL the texture must be realized
-- using LoadTexture(image) method.
Destroy(me);
Destroy (me);
---C++ : alias ~
--
-- public methods
--
IsDone(me) returns Boolean from Standard;
IsDone (me) returns Boolean from Standard;
---Level: public
---Purpose: Checks if a texture class is valide or not
---Purpose: Checks if a texture class is valid or not
-- returns true if the construction of the class is correct
Path(me) returns Path from OSD;
IsValid (me) returns Boolean from Standard;
---Level: public
---Purpose: Checks if a texture class is valid or not
-- returns true if the construction of the class is correct
Path (me) returns Path from OSD;
---Level: public
---Purpose:
-- Returns the full path of the defined texture.
---C++: return const &
Type(me) returns TypeOfTexture from Graphic3d;
Type (me) returns TypeOfTexture from Graphic3d;
---Level: public
---Purpose:
-- Returns the texture type.
--
-- private methods
--
Update(me) is protected;
LoadTexture(me : mutable; anImage: AlienImage from AlienImage);
---Level: advanced
LoadTexture (me : mutable; theImage : PixMap from Image) returns Boolean from Standard;
---Level: advanced
---Purpose:
-- Updates the current texture from a requested alien image.
-- Updates the current texture from a requested image.
LoadTexture(me)
returns AlienImage from AlienImage
is private;
TextureId(me) returns Integer from Standard;
---Level: advanced
TextureId (me) returns Integer from Standard;
---Level: advanced
---Purpose:
-- returns the Texture ID which references the
-- texture to use for drawing. Used by the
-- graphic driver.
-- texture to use for drawing. Used by the graphic driver.
Image(me) returns AlienImage from AlienImage;
---Level: advanced
---Purpose:
-- Returns the created image texture.
GetTexUpperBounds(me) returns HArray1OfReal from TColStd;
---Level: advanced
GetTexUpperBounds(me) returns HArray1OfReal from TColStd;
---Level: advanced
---Purpose:
---Gets upper bounds of texture coordinates. This is used when sizes
---of texture are not equal to the powers of two
-- internal fields for managing the class
fields
MyGraphicDriver : GraphicDriver from Graphic3d;
MyTexId : Integer from Standard;
MyCInitTexture : CInitTexture from Graphic3d is protected;
-- MyIsDone : Boolean from Standard;
MyPath : Path from OSD;
MyType : TypeOfTexture from Graphic3d;
MyImage : AlienImage from AlienImage;
MyTexUpperBounds : HArray1OfReal from TColStd;
end TextureRoot;
--
-- private methods
--
Update (me) is protected;
fields
myGraphicDriver : GraphicDriver from Graphic3d;
myTexId : Integer from Standard;
MyCInitTexture : CInitTexture from Graphic3d is protected;
myPath : Path from OSD;
myType : TypeOfTexture from Graphic3d;
myTexUpperBounds : HArray1OfReal from TColStd;
end TextureRoot;

265
src/Graphic3d/Graphic3d_TextureRoot.cxx
View File

@ -18,215 +18,142 @@
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.
// modified:
// 8/09/97 : mise en commentaire des tentatives pour charger
// autre chose que du RGB. AlienImage buggee ?
// 5/01/99 : Ajout test sur les objets Path et FileName dans LoadTexture().
// Si le path est null on trappe.
// 11/06/99 : GG Enable to use GIF and BMP image format
// 10/01/00 : GG IMP Add Path() and Type() methods.
// 10/11/00 : GG Add Image() & LoadTexture() methods.
#define IMP140601 //GG Avoid to change the Trek of the current defined path
// when the directory string is NULL or empty.
#define xTRACE 1
#include <Graphic3d_TextureRoot.ixx>
#include <Graphic3d_GraphicDevice.hxx>
#include <Graphic3d_GraphicDriver.hxx>
#include <AlienImage_EuclidAlienImage.hxx>
#include <AlienImage_SGIRGBAlienImage.hxx>
#include <AlienImage_XAlienImage.hxx>
#include <AlienImage_GIFAlienImage.hxx>
#include <AlienImage_BMPAlienImage.hxx>
#include <AlienImage_AidaAlienImage.hxx>
#include <AlienImage_SunRFAlienImage.hxx>
#include <AlienImage_AlienImage.hxx>
#include <Image_AlienPixMap.hxx>
#include <OSD_Protection.hxx>
#include <OSD_File.hxx>
#include <stdio.h>
Graphic3d_TextureRoot::Graphic3d_TextureRoot(const Handle(Graphic3d_StructureManager)& SM,const Standard_CString Path,const Standard_CString FileName,const Graphic3d_TypeOfTexture Type) : MyPath(FileName),MyType(Type)
// =======================================================================
// function : Graphic3d_TextureRoot
// purpose :
// =======================================================================
Graphic3d_TextureRoot::Graphic3d_TextureRoot (const Handle(Graphic3d_StructureManager)& theSM,
const Standard_CString thePath,
const Standard_CString theFileName,
const Graphic3d_TypeOfTexture theType)
: myGraphicDriver (Handle(Graphic3d_GraphicDriver)::DownCast (theSM->GraphicDevice()->GraphicDriver())),
myTexId (-1),
myPath (theFileName),
myType (theType),
myTexUpperBounds (new TColStd_HArray1OfReal (1, 2)) // currently always allocating an array for two texture bounds...
{
// It will be necessary to improve the code below as soon as 3D or 4D textures
// are implemented. Currently, always allocating an array for two texture bounds...
MyTexUpperBounds = new TColStd_HArray1OfReal(1,2);
#ifdef IMP140601
if( Path && (strlen(Path) > 0) )
#endif
MyPath.SetTrek(TCollection_AsciiString( Path ));
MyGraphicDriver = Handle(Graphic3d_GraphicDriver)::DownCast(SM->GraphicDevice()->GraphicDriver());
if (MyGraphicDriver->InquireTextureAvailable())
if (thePath != NULL && (strlen (thePath) > 0))
{
// chargement de l'image
//-GG Handle(AlienImage_AlienImage) MyImage = LoadTexture();
if (MyImage.IsNull() && FileName && (strlen(FileName) > 0))
MyImage = LoadTexture();
if (MyImage.IsNull()) {
MyTexId = -1;
return;
}
MyTexId = MyGraphicDriver->CreateTexture(Type, MyImage, FileName, MyTexUpperBounds);
myPath.SetTrek (TCollection_AsciiString (thePath));
}
#ifdef TRACE
printf(" *** Graphic3d_TextureRoot::Create() textId %d\n",MyTexId);
#endif
if (theFileName == NULL || (strlen (theFileName) <= 0))
{
return;
}
TCollection_AsciiString aFilePath;
myPath.SystemName (aFilePath);
Image_AlienPixMap anImage;
if (!anImage.Load (aFilePath))
{
return;
}
myTexId = myGraphicDriver->CreateTexture (myType, anImage, theFileName, myTexUpperBounds);
Update();
}
// =======================================================================
// function : Destroy
// purpose :
// =======================================================================
void Graphic3d_TextureRoot::Destroy() const
{
if (MyTexId >= 0 )
MyGraphicDriver->DestroyTexture(MyTexId);
#ifdef TRACE
printf(" *** Graphic3d_TextureRoot::Destroy() textId %d\n",MyTexId);
#endif
if (IsValid())
{
myGraphicDriver->DestroyTexture (myTexId);
}
}
// =======================================================================
// function : TextureId
// purpose :
// =======================================================================
Standard_Integer Graphic3d_TextureRoot::TextureId() const
{
return MyTexId;
return myTexId;
}
// =======================================================================
// function : Update
// purpose :
// =======================================================================
void Graphic3d_TextureRoot::Update() const
{
if( MyTexId >= 0 )
MyGraphicDriver->ModifyTexture(MyTexId, MyCInitTexture);
if (IsValid())
{
myGraphicDriver->ModifyTexture (myTexId, MyCInitTexture);
}
}
// =======================================================================
// function : IsValid
// purpose :
// =======================================================================
Standard_Boolean Graphic3d_TextureRoot::IsValid() const
{
return myTexId >= 0;
}
// =======================================================================
// function : IsDone
// purpose :
// =======================================================================
Standard_Boolean Graphic3d_TextureRoot::IsDone() const
{
return (MyTexId >= 0) ? Standard_True : Standard_False;
return myTexId >= 0;
}
void Graphic3d_TextureRoot::LoadTexture(const Handle(AlienImage_AlienImage)& anImage) {
if (MyGraphicDriver->InquireTextureAvailable()) {
if( MyTexId >= 0 )
MyGraphicDriver->DestroyTexture(MyTexId);
MyImage = anImage;
MyTexId = MyGraphicDriver->CreateTexture(MyType, MyImage, "", MyTexUpperBounds);
Update();
}
}
Handle(AlienImage_AlienImage) Graphic3d_TextureRoot::LoadTexture() const
// =======================================================================
// function : LoadTexture
// purpose :
// =======================================================================
Standard_Boolean Graphic3d_TextureRoot::LoadTexture (const Image_PixMap& theImage)
{
OSD_Protection Protection( OSD_R, OSD_R, OSD_R, OSD_R ) ; /* Read Only */
Handle(AlienImage_AlienImage) TheAlienImage = NULL ;
OSD_File File(MyPath);
File.Open(OSD_ReadOnly, Protection);
// open file ok ?
if ( File.IsOpen() == Standard_False ) {
TCollection_AsciiString sysname;
MyPath.SystemName(sysname);
cout << " *** Can't open texture file '" << sysname << "'" << endl;
return TheAlienImage;
if (myTexId >= 0)
{
myGraphicDriver->DestroyTexture (myTexId);
}
////////////////////////
// file reading //
////////////////////////
// image X ?
////////////
Handle(AlienImage_XAlienImage) XAlienImage = new AlienImage_XAlienImage() ;
if (XAlienImage->Read( File )) {
File.Close();
return XAlienImage;
}
// image GIF ?
////////////
Handle(AlienImage_GIFAlienImage) GIFAlienImage = new AlienImage_GIFAlienImage() ;
if (GIFAlienImage->Read( File )) {
File.Close();
return GIFAlienImage;
}
// image BMP ?
////////////
Handle(AlienImage_BMPAlienImage) BMPAlienImage = new AlienImage_BMPAlienImage() ;
if (BMPAlienImage->Read( File )) {
File.Close();
return BMPAlienImage;
}
// SunRaster ?
//////////////
Handle(AlienImage_SunRFAlienImage) SunRFAlienImage = new AlienImage_SunRFAlienImage() ;
if (SunRFAlienImage->Read( File )) {
File.Close();
return SunRFAlienImage;
}
// Aida ?
/////////
Handle(AlienImage_AidaAlienImage) AidaAlienImage = new AlienImage_AidaAlienImage() ;
if (AidaAlienImage->Read( File )) {
File.Close();
return AidaAlienImage;
}
// Euclid ?
///////////
Handle(AlienImage_EuclidAlienImage) EuclidAlienImage = new AlienImage_EuclidAlienImage() ;
if (EuclidAlienImage->Read( File )) {
File.Close();
return EuclidAlienImage;
}
// SGIRGB ?
///////////
Handle(AlienImage_SGIRGBAlienImage) SGIRGBAlienImage = new AlienImage_SGIRGBAlienImage() ;
if (SGIRGBAlienImage->Read( File )) {
File.Close();
return SGIRGBAlienImage;
}
// raise exception: file type unknown
return TheAlienImage;
myTexId = myGraphicDriver->CreateTexture (myType, theImage, "", myTexUpperBounds);
Update();
return IsValid();
}
const OSD_Path& Graphic3d_TextureRoot::Path() const {
return MyPath;
// =======================================================================
// function : Path
// purpose :
// =======================================================================
const OSD_Path& Graphic3d_TextureRoot::Path() const
{
return myPath;
}
Graphic3d_TypeOfTexture Graphic3d_TextureRoot::Type() const {
return MyType;
}
Handle(AlienImage_AlienImage) Graphic3d_TextureRoot::Image() const {
return MyImage;
// =======================================================================
// function : Type
// purpose :
// =======================================================================
Graphic3d_TypeOfTexture Graphic3d_TextureRoot::Type() const
{
return myType;
}
// =======================================================================
// function : GetTexUpperBounds
// purpose :
// =======================================================================
Handle(TColStd_HArray1OfReal) Graphic3d_TextureRoot::GetTexUpperBounds() const
{
return MyTexUpperBounds;
return myTexUpperBounds;
}

3
src/Image/Image_AlienPixMap.cxx
View File

@ -182,7 +182,7 @@ bool Image_AlienPixMap::InitTrash (ImgFormat thePixelFormat,
}
// =======================================================================
// function : Clear
// function : InitCopy
// purpose :
// =======================================================================
bool Image_AlienPixMap::InitCopy (const Image_PixMap& theCopy)
@ -368,7 +368,6 @@ bool Image_AlienPixMap::Save (const TCollection_AsciiString& theFileName)
// FreeImage doesn't provide flexible format convertion API
// so we should perform multiple convertions in some cases!
Standard_Boolean isCopied = Standard_False;
FIBITMAP* anImageToDump = myLibImage;
switch (anImageFormat)
{

249
src/MeshVS/MeshVS_NodalColorPrsBuilder.cxx
View File

@ -53,9 +53,7 @@
#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>
@ -72,22 +70,21 @@
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;
@ -116,7 +113,7 @@ MeshVS_ImageTexture2D::~MeshVS_ImageTexture2D()
//================================================================
// 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 )
@ -130,7 +127,7 @@ 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 )
*/
@ -144,7 +141,7 @@ MeshVS_NodalColorPrsBuilder::MeshVS_NodalColorPrsBuilder ( const Handle(MeshVS_M
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 );
@ -177,7 +174,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
if ( !( DisplayMode & GetFlags() ) || !IsElement )
return;
if ( myUseTexture && ( !myTextureCoords.Extent() || !myTextureColorMap.Length() ) ||
if ( myUseTexture && ( !myTextureCoords.Extent() || !myTextureColorMap.Length() ) ||
!myUseTexture && !myNodeColorMap.Extent() )
return;
@ -192,7 +189,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
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)
@ -201,7 +198,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
nbColors = myTextureColorMap.Length();
nbTextureColors = getNearestPow2( nbColors );
}
Standard_Integer aSize = anIDs.Extent();
// Calculate maximum possible number of vertices and bounds
@ -220,7 +217,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
// 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;
@ -249,17 +246,17 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
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 );
@ -300,7 +297,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
// 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 )
@ -316,52 +313,52 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
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
@ -385,7 +382,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
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 );
@ -397,59 +394,59 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
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
@ -468,8 +465,8 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
// if IsExcludingOn then presentation must not be built by other builders
if ( IsExcludingOn() )
IDsToExclude.Add( aKey );
}
}
}
}
} // for ( ...
Handle(Graphic3d_AspectFillArea3d) anAsp;
@ -497,7 +494,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
Handle(AIS_Drawer) anAISDrawer = myParentMesh->Attributes();
if ( anAISDrawer.IsNull() )
return;
anAISDrawer->SetShadingAspect( new Prs3d_ShadingAspect() );
anAsp = anAISDrawer->ShadingAspect()->Aspect();
if ( anAsp.IsNull() )
@ -505,13 +502,13 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
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 );
}
@ -520,7 +517,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
// 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 ] );
}
@ -528,12 +525,12 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
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 );
@ -545,7 +542,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
Handle(Graphic3d_Group) aGroup2 = Prs3d_Root::CurrentGroup ( Prs );
anAsp->SetEdgeOff();
anAsp->SetTextureMapOff();
anAsp->SetTextureMapOff();
aGroup2->SetPrimitivesAspect( anAsp );
aGroup2->SetPrimitivesAspect( anLAsp );
aGroup2->BeginPrimitives();
@ -559,7 +556,7 @@ void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
// Function : SetColors
// Purpose :
//================================================================
void MeshVS_NodalColorPrsBuilder::SetColors (
void MeshVS_NodalColorPrsBuilder::SetColors (
const MeshVS_DataMapOfIntegerColor& theColorMap )
{
myNodeColorMap = theColorMap;
@ -634,7 +631,7 @@ Standard_Boolean MeshVS_NodalColorPrsBuilder::IsUseTexture() const
//================================================================
// 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 )
@ -644,7 +641,7 @@ void MeshVS_NodalColorPrsBuilder::SetColorMap( const Aspect_SequenceOfColor& the
//================================================================
// Function : GetColorMap
// Purpose : Return colors used for texrture presentation
// Purpose : Return colors used for texrture presentation
//================================================================
const Aspect_SequenceOfColor& MeshVS_NodalColorPrsBuilder::GetColorMap() const
{
@ -653,10 +650,10 @@ 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;
@ -674,10 +671,10 @@ Quantity_Color MeshVS_NodalColorPrsBuilder::GetInvalidColor() const
//================================================================
// 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;
@ -685,8 +682,8 @@ void MeshVS_NodalColorPrsBuilder::SetTextureCoords (
//================================================================
// 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
{
@ -695,8 +692,8 @@ const TColStd_DataMapOfIntegerReal& MeshVS_NodalColorPrsBuilder::GetTextureCoord
//================================================================
// 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 )
@ -706,8 +703,8 @@ void MeshVS_NodalColorPrsBuilder::SetTextureCoord( const Standard_Integer theID,
//================================================================
// 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 )
{
@ -720,43 +717,65 @@ Standard_Real MeshVS_NodalColorPrsBuilder::GetTextureCoord( const Standard_Integ
//================================================================
Handle(Graphic3d_Texture2D) MeshVS_NodalColorPrsBuilder::CreateTexture() const
{
Handle(Graphic3d_Texture2D) aTexture;
int nbColors = myTextureColorMap.Length();
if ( nbColors == 0 )
return aTexture;
Handle(PrsMgr_PresentationManager3d) aPrsMgr = GetPresentationManager();
if ( aPrsMgr.IsNull() )
return aTexture;
int nbTextureColors = getNearestPow2( nbColors );
// Create and fill image with colors
Handle(Image_ColorImage) aCImage =
new Image_ColorImage( 0, 0, nbTextureColors, 2 );
if ( nbColors > 0 )
const Standard_Integer aColorsNb = myTextureColorMap.Length();
if (aColorsNb == 0)
{
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 ) );
}
return NULL;
}
// Convert image to bmp
Handle(AlienImage_BMPAlienImage) aTextureImage = new AlienImage_BMPAlienImage();
aTextureImage->FromImage( aCImage );
Handle(PrsMgr_PresentationManager3d) aPrsMgr = GetPresentationManager();
if (aPrsMgr.IsNull())
{
return NULL;
}
// Create texture
aTexture = new MeshVS_ImageTexture2D( aPrsMgr->StructureManager(), aTextureImage );
return aTexture;
// create and fill image with colors
Image_PixMap anImage;
if (!anImage.InitTrash (Image_PixMap::ImgRGBA, Standard_Size(getNearestPow2 (aColorsNb)), 2))
{
return NULL;
}
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;
}
// 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)
{
aData.ChangeValue (0, aCol) = aLastColor;
}
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
return new MeshVS_ImageTexture2D (aPrsMgr->StructureManager(), anImage);
}

8
src/OpenGl/OpenGl_GraphicDriver.hxx
View File

@ -103,7 +103,6 @@ class OpenGl_GraphicDriver : public Graphic3d_GraphicDriver
Standard_EXPORT Standard_Integer InquireLightLimit ();
Standard_EXPORT void InquireMat (const Graphic3d_CView& ACView, TColStd_Array2OfReal& AMatO, TColStd_Array2OfReal& AMatM);
Standard_EXPORT Standard_Integer InquireViewLimit ();
Standard_EXPORT Standard_Boolean InquireTextureAvailable ();
Standard_EXPORT void Blink (const Graphic3d_CStructure& ACStructure,const Standard_Boolean Create);
Standard_EXPORT void BoundaryBox (const Graphic3d_CStructure& ACStructure, const Standard_Boolean Create);
Standard_EXPORT void HighlightColor (const Graphic3d_CStructure& ACStructure, const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B, const Standard_Boolean Create);
@ -273,14 +272,17 @@ public:
//! This method is internal and should be used by Graphic3d_Group only. <br>
Standard_EXPORT void RemovePrimitiveArray(const Graphic3d_CGroup& theCGroup,const Graphic3d_PrimitiveArray& thePArray);
Standard_EXPORT Standard_Integer InquirePlaneLimit();
Standard_EXPORT Standard_Integer CreateTexture(const Graphic3d_TypeOfTexture Type,const Handle(AlienImage_AlienImage)& Image,const Standard_CString FileName,const Handle(TColStd_HArray1OfReal)& TexUpperBounds) const;
Standard_EXPORT Standard_Integer CreateTexture (const Graphic3d_TypeOfTexture theType,
const Image_PixMap& theImage,
const Standard_CString theFileName,
const Handle(TColStd_HArray1OfReal)& theTexUpperBounds) const;
Standard_EXPORT void DestroyTexture(const Standard_Integer TexId) const;
Standard_EXPORT void ModifyTexture(const Standard_Integer TexId,const Graphic3d_CInitTexture& AValue) const;
Standard_EXPORT Standard_ShortReal DefaultTextHeight() const;
Standard_EXPORT void FBOGetDimensions(const Graphic3d_CView& view,const Graphic3d_PtrFrameBuffer fboPtr,Standard_Integer& width,Standard_Integer& height,Standard_Integer& widthMax,Standard_Integer& heightMax);
Standard_EXPORT void FBOChangeViewport(const Graphic3d_CView& view,Graphic3d_PtrFrameBuffer& fboPtr,const Standard_Integer width,const Standard_Integer height);
Standard_EXPORT Standard_Boolean Export(const Standard_CString theFileName,const Graphic3d_ExportFormat theFormat,const Graphic3d_SortType theSortType,const Standard_Integer theWidth,const Standard_Integer theHeight,const Graphic3d_CView& theView,const Aspect_CLayer2d& theLayerUnder,const Aspect_CLayer2d& theLayerOver,const Standard_Real thePrecision = 0.005,const Standard_Address theProgressBarFunc = NULL,const Standard_Address theProgressObject = NULL);
//! Add a new top-level z layer with ID <theLayerId> for <br>
//! the view. Z layers allow drawing structures in higher layers <br>
//! in foreground of structures in lower layers. To add a structure <br>

5
src/OpenGl/OpenGl_GraphicDriver_2.cxx
View File

@ -42,11 +42,6 @@ Standard_Integer OpenGl_GraphicDriver::InquireViewLimit ()
return (openglDisplay.IsNull()? 0 : openglDisplay->Facilities().MaxViews);
}
Standard_Boolean OpenGl_GraphicDriver::InquireTextureAvailable ()
{
return Standard_True;
}
Standard_Integer OpenGl_GraphicDriver::InquirePlaneLimit ()
{
GLint aMaxPlanes = 0;

140
src/OpenGl/OpenGl_GraphicDriver_9.cxx
View File

@ -17,7 +17,6 @@
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_CView.hxx>
#include <OpenGl_Trihedron.hxx>
@ -27,7 +26,6 @@
#include <Quantity_NameOfColor.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <AlienImage_AlienImage.hxx>
#include <Image_Image.hxx>
void OpenGl_GraphicDriver::Environment(const Graphic3d_CView& ACView)
@ -58,7 +56,7 @@ void OpenGl_GraphicDriver::ZBufferTriedronSetup (
void OpenGl_GraphicDriver::TriedronDisplay (
const Graphic3d_CView& ACView,
const Aspect_TypeOfTriedronPosition APosition,
const Quantity_NameOfColor AColor,
const Quantity_NameOfColor AColor,
const Standard_Real AScale,
const Standard_Boolean AsWireframe )
{
@ -69,7 +67,7 @@ void OpenGl_GraphicDriver::TriedronDisplay (
}
}
void OpenGl_GraphicDriver::TriedronErase (const Graphic3d_CView& ACView)
void OpenGl_GraphicDriver::TriedronErase (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
@ -83,7 +81,7 @@ void OpenGl_GraphicDriver::TriedronEcho (const Graphic3d_CView& ACView,const Asp
// Do nothing
}
void OpenGl_GraphicDriver::BackgroundImage( const Standard_CString FileName,
void OpenGl_GraphicDriver::BackgroundImage( const Standard_CString FileName,
const Graphic3d_CView& ACView,
const Aspect_FillMethod FillStyle )
{
@ -151,79 +149,81 @@ inline Standard_Integer GetNearestPow2(Standard_Integer theValue)
return aRes;
}
Standard_Integer OpenGl_GraphicDriver::CreateTexture (const Graphic3d_TypeOfTexture Type,
const Handle_AlienImage_AlienImage &Image,
const Standard_CString FileName,
const Handle(TColStd_HArray1OfReal)& TexUpperBounds) const
Standard_Integer OpenGl_GraphicDriver::CreateTexture (const Graphic3d_TypeOfTexture theType,
const Image_PixMap& theImage,
const Standard_CString theFileName,
const Handle(TColStd_HArray1OfReal)& theTexUpperBounds) const
{
Handle(Image_Image) MyPic = Image->ToImage();
Standard_Integer aGlWidth = (Type == Graphic3d_TOT_2D_MIPMAP) ? MyPic->Width() : GetNearestPow2(MyPic->Width());
Standard_Integer aGlHeight = (Type == Graphic3d_TOT_2D_MIPMAP) ? MyPic->Height() : GetNearestPow2(MyPic->Height());
TexUpperBounds->SetValue(1, ((Standard_Real) (MyPic->Width())/((Standard_Real) aGlWidth)));
TexUpperBounds->SetValue(2, ((Standard_Real) (MyPic->Height())/((Standard_Real) aGlHeight)));
unsigned char *MyImageData = new unsigned char[aGlWidth*aGlHeight*4];
unsigned char *MyData = MyImageData;
int TexId;
int i,j;
Quantity_Color MyColor;
if (MyImageData == NULL)
if (theImage.IsEmpty())
{
return -1;
}
static Standard_Integer textureRank=0;
char textureName[16];
Standard_PCharacter fileName = textureName;
sprintf(fileName,"Tex%d",++textureRank);
Standard_Integer aGlWidth = (Standard_Integer )theImage.Width();
Standard_Integer aGlHeight = (Standard_Integer )theImage.Height();
if (theType != Graphic3d_TOT_2D_MIPMAP)
{
aGlWidth = GetNearestPow2 (aGlWidth);
aGlHeight = GetNearestPow2 (aGlHeight);
}
theTexUpperBounds->SetValue (1, Standard_Real(theImage.Width()) / Standard_Real(aGlWidth));
theTexUpperBounds->SetValue (2, Standard_Real(theImage.Height()) / Standard_Real(aGlHeight));
for (j = MyPic->Height() - 1; j >= 0; j--)
for (i = 0; i < aGlWidth; i++){
if (i < MyPic->Width()){
MyColor = MyPic->PixelColor(i, j);
*MyData++ = (int)(255 * MyColor.Red());
*MyData++ = (int)(255 * MyColor.Green());
*MyData++ = (int)(255 * MyColor.Blue());
}
else {
*MyData++ = (int)(0);
*MyData++ = (int)(0);
*MyData++ = (int)(0);
}
*MyData++ = 0xFF;
}
Image_PixMap anImage;
if (!anImage.InitTrash (Image_PixMap::ImgRGBA, Standard_Size(aGlWidth), Standard_Size(aGlHeight)))
{
return -1;
}
// Padding the lower part of the texture with black
for (j = aGlHeight - 1; j >= MyPic->Height(); j--)
for (i = 0; i < aGlWidth; i++){
*MyData++ = (int)(0);
*MyData++ = (int)(0);
*MyData++ = (int)(0);
*MyData++ = 0xFF;
}
anImage.SetTopDown (false);
Image_PixMapData<Image_ColorRGBA>& aDataNew = anImage.EditData<Image_ColorRGBA>();
Quantity_Color aSrcColor;
for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
for (Standard_Size aCol = 0; aCol < theImage.SizeX(); ++aCol)
{
aSrcColor = theImage.PixelColor (aCol, aRow);
Image_ColorRGBA& aColor = aDataNew.ChangeValue (aRow, 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;
}
switch (Type)
{
case Graphic3d_TOT_1D:
TexId = GetTextureData1D (fileName, aGlWidth, aGlHeight, MyImageData);
break;
for (Standard_Size aCol = theImage.SizeX(); aCol < anImage.SizeX(); ++aCol)
{
Image_ColorRGBA& aColor = aDataNew.ChangeValue (aRow, aCol);
aColor.r() = 0x00;
aColor.g() = 0x00;
aColor.b() = 0x00;
aColor.a() = 0xFF;
}
}
case Graphic3d_TOT_2D:
TexId = GetTextureData2D (fileName, aGlWidth, aGlHeight, MyImageData);
break;
// Padding the lower part of the texture with black
for (Standard_Size aRow = theImage.SizeY(); aRow < anImage.SizeY(); ++aRow)
{
for (Standard_Size aCol = 0; aCol < anImage.SizeX(); ++aCol)
{
Image_ColorRGBA& aColor = aDataNew.ChangeValue (aRow, aCol);
aColor.r() = 0x00;
aColor.g() = 0x00;
aColor.b() = 0x00;
aColor.a() = 0xFF;
}
}
case Graphic3d_TOT_2D_MIPMAP:
TexId = GetTextureData2DMipMap (fileName, aGlWidth, aGlHeight, MyImageData);
break;
default:
TexId = -1;
}
delete [] MyImageData;
return TexId;
static Standard_Integer TheTextureRank = 0;
char aTextureStrId[255];
sprintf (aTextureStrId, "Tex%d", ++TheTextureRank);
switch (theType)
{
case Graphic3d_TOT_1D: return GetTextureData1D (aTextureStrId, aGlWidth, aGlHeight, anImage.Data());
case Graphic3d_TOT_2D: return GetTextureData2D (aTextureStrId, aGlWidth, aGlHeight, anImage.Data());
case Graphic3d_TOT_2D_MIPMAP: return GetTextureData2DMipMap (aTextureStrId, aGlWidth, aGlHeight, anImage.Data());
default: return -1;
}
}
void OpenGl_GraphicDriver::DestroyTexture (const Standard_Integer theTexId) const
@ -260,7 +260,7 @@ void OpenGl_GraphicDriver::ModifyTexture (const Standard_Integer theTexId
case 3:
SetModeManual (theTexId);
break;
break;
}
if (theInfo.doLinear)

177
src/OpenGl/OpenGl_View_2.cxx
View File

@ -17,7 +17,6 @@
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.
#include <stdio.h>
#include <stdlib.h>
@ -25,8 +24,7 @@
#include <OpenGl_tgl_funcs.hxx>
#include <OpenGl_TextureBox.hxx>
#include <AlienImage.hxx>
#include <Image_Image.hxx>
#include <Image_AlienPixMap.hxx>
#include <Visual3d_Layer.hxx>
#include <OpenGl_AspectLine.hxx>
@ -105,7 +103,7 @@ static void bind_light(const OpenGl_Light *lptr, int *gl_lid)
* The GL_AMBIENT parameter refers to RGBA intensity of the ambient
* light.
*/
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, data_amb);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, data_amb);
break;
@ -124,7 +122,7 @@ static void bind_light(const OpenGl_Light *lptr, int *gl_lid)
corresponding light source is a Directional one.
GL_SPOT_CUTOFF a 180 signifie que ce n'est pas un spot.
To create a realistic effect, set the GL_SPECULAR parameter
To create a realistic effect, set the GL_SPECULAR parameter
to the same value as the GL_DIFFUSE.
*/
@ -159,7 +157,7 @@ static void bind_light(const OpenGl_Light *lptr, int *gl_lid)
GL_SPOT_CUTOFF a 180 signifie que ce n'est pas un spot.
To create a realistic effect, set the GL_SPECULAR parameter
To create a realistic effect, set the GL_SPECULAR parameter
to the same value as the GL_DIFFUSE.
*/
@ -181,7 +179,7 @@ static void bind_light(const OpenGl_Light *lptr, int *gl_lid)
glLightf(*gl_lid, GL_SPOT_CUTOFF, default_sptcutoff);
glLightf(*gl_lid, GL_CONSTANT_ATTENUATION, data_constantattenuation);
glLightf(*gl_lid, GL_LINEAR_ATTENUATION, data_linearattenuation);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
break;
@ -208,20 +206,20 @@ static void bind_light(const OpenGl_Light *lptr, int *gl_lid)
glLightfv(*gl_lid, GL_AMBIENT, default_amb);
glLightfv(*gl_lid, GL_DIFFUSE, data_diffu);
glLightfv(*gl_lid, GL_SPECULAR, data_diffu);
glLightfv(*gl_lid, GL_SPECULAR, data_diffu);
glLightfv(*gl_lid, GL_POSITION, data_pos);
glLightfv(*gl_lid, GL_POSITION, data_pos);
glLightfv(*gl_lid, GL_SPOT_DIRECTION, data_sptdir);
glLightf(*gl_lid, GL_SPOT_EXPONENT, data_sptexpo);
glLightf(*gl_lid, GL_SPOT_CUTOFF, data_sptcutoff);
glLightf(*gl_lid, GL_CONSTANT_ATTENUATION, data_constantattenuation);
glLightf(*gl_lid, GL_LINEAR_ATTENUATION, data_linearattenuation);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
break;
}
if (lptr->type != TLightAmbient)
{
if (lptr->type != TLightAmbient)
{
glEnable(*gl_lid);
(*gl_lid)++;
}
@ -255,7 +253,7 @@ static void call_util_mat_mul( matrix3 mat_a, matrix3 mat_b, matrix3 mat_c);
void call_func_eval_ori_matrix3 (const point3* vrp, // view reference point
const vec3* vpn, // view plane normal
const vec3* vup, // view up vector
int* err_ind,
int* err_ind,
float mout[4][4]) // OUT view orientation matrix
{
@ -369,8 +367,8 @@ void call_func_eval_ori_matrix3 (const point3* vrp, // view reference poi
*/
/* OCC18942: obsolete in OCCT6.3, might be removed in further versions! */
void call_func_eval_map_matrix3(
view_map3 *Map,
int *err_ind,
view_map3 *Map,
int *err_ind,
matrix3 mat)
{
int i, j;
@ -395,7 +393,7 @@ void call_func_eval_map_matrix3(
/*
* Type Parallele
*/
*/
if (Map->proj_type == TYPE_PARAL)
{
float umid, vmid;
@ -450,7 +448,7 @@ void call_func_eval_map_matrix3(
call_util_mat_mul( tmat, shmat, tshmat );
call_util_mat_mul( smat, tshmat, mat );
return;
return;
#endif
/* CAL */
@ -511,12 +509,12 @@ void call_func_eval_map_matrix3(
aux_mat1[3][2] = Map->proj_vp.z_min;
call_util_mat_mul (aux_mat2, aux_mat1, mat);
return;
}
return;
}
/*
* Type Perspective
*/
*/
else if (Map->proj_type == TYPE_PERSPECT)
{
float umid, vmid;
@ -719,21 +717,21 @@ void OpenGl_View::Render (const Handle(OpenGl_Workspace) &AWorkspace,
break;
case Aspect_GFM_DIAG1:
corner2 = myBgGradient.color2.rgb;
corner4 = myBgGradient.color1.rgb;
corner4 = myBgGradient.color1.rgb;
dcorner1 [0] = dcorner2[0] = 0.5F * (corner2[0] + corner4[0]);
dcorner1 [1] = dcorner2[1] = 0.5F * (corner2[1] + corner4[1]);
dcorner1 [2] = dcorner2[2] = 0.5F * (corner2[2] + corner4[2]);
corner1 = dcorner1;
corner3 = dcorner2;
corner3 = dcorner2;
break;
case Aspect_GFM_DIAG2:
corner1 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color1.rgb;
corner1 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color1.rgb;
dcorner1 [0] = dcorner2[0] = 0.5F * (corner1[0] + corner3[0]);
dcorner1 [1] = dcorner2[1] = 0.5F * (corner1[1] + corner3[1]);
dcorner1 [2] = dcorner2[2] = 0.5F * (corner1[2] + corner3[2]);
corner2 = dcorner1;
corner4 = dcorner2;
corner4 = dcorner2;
break;
case Aspect_GFM_CORNER1:
corner1 = myBgGradient.color2.rgb;
@ -779,7 +777,7 @@ void OpenGl_View::Render (const Handle(OpenGl_Workspace) &AWorkspace,
glColor3f(corner2[0],corner2[1],corner2[2]); glVertex2f( 1.,-1.);
glColor3f(corner3[0],corner3[1],corner3[2]); glVertex2f( 1., 1.);
glColor3f(corner4[0],corner4[1],corner4[2]); glVertex2f(-1., 1.);
}
}
else //if ( myBgGradient.type == Aspect_GFM_CORNER1 || myBgGradient.type == Aspect_GFM_CORNER3 )
{
glColor3f(corner2[0],corner2[1],corner2[2]); glVertex2f( 1.,-1.);
@ -889,11 +887,11 @@ void OpenGl_View::Render (const Handle(OpenGl_Workspace) &AWorkspace,
//TsmPushAttri(); /* save previous graphics context */
// if the view is scaled normal vectors are scaled to unit length for correct displaying of shaded objects
if(myExtra.scaleFactors[0] != 1.F ||
if(myExtra.scaleFactors[0] != 1.F ||
myExtra.scaleFactors[1] != 1.F ||
myExtra.scaleFactors[2] != 1.F)
glEnable(GL_NORMALIZE);
else if(glIsEnabled(GL_NORMALIZE))
else if(glIsEnabled(GL_NORMALIZE))
glDisable(GL_NORMALIZE);
// Apply View Projection
@ -1147,12 +1145,12 @@ D = -[Px,Py,Pz] dot |Nx|
GLboolean zbuff_w;
glGetBooleanv(GL_DEPTH_WRITEMASK, &zbuff_w);
glGetIntegerv(GL_DEPTH_FUNC, &zbuff_f);
glGetIntegerv(GL_BLEND_DST, &blend_dst);
glGetIntegerv(GL_BLEND_SRC, &blend_src);
glGetIntegerv(GL_BLEND_DST, &blend_dst);
glGetIntegerv(GL_BLEND_SRC, &blend_src);
GLboolean zbuff_state = glIsEnabled(GL_DEPTH_TEST);
GLboolean blend_state = glIsEnabled(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glDepthFunc(GL_EQUAL);
@ -1263,7 +1261,7 @@ void OpenGl_View::RenderStructs (const Handle(OpenGl_Workspace) &AWorkspace)
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
if( antiAliasingMode & 2 ) glEnable(GL_POLYGON_SMOOTH);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
}
}
@ -1378,7 +1376,7 @@ void OpenGl_View::RedrawLayer2d (const Handle(OpenGl_Workspace) &AWorkspace, con
if (anViewportX != 0 && anViewportY != 0)
glViewport (0, 0, anViewportX, anViewportY);
}
#endif
#endif
glOrtho (left, right, bottom, top, -1.0, 1.0);
@ -1419,53 +1417,78 @@ void OpenGl_View::RedrawLayer2d (const Handle(OpenGl_Workspace) &AWorkspace, con
/*----------------------------------------------------------------------*/
//call_togl_create_bg_texture
void OpenGl_View::CreateBackgroundTexture (const Standard_CString AFileName, const Aspect_FillMethod AFillStyle)
void OpenGl_View::CreateBackgroundTexture (const Standard_CString theFilePath,
const Aspect_FillMethod theFillStyle)
{
// Delete existing texture
if ( myBgTexture.TexId != 0 )
if (myBgTexture.TexId != 0)
{
glDeleteTextures( 1, (GLuint*)&(myBgTexture.TexId) );
// delete existing texture
glDeleteTextures (1, (GLuint* )&(myBgTexture.TexId));
myBgTexture.TexId = 0;
}
Standard_Integer width, height;
Handle(Image_Image) image;
if ( AlienImage::LoadImageFile( AFileName, image, width, height ) )
// load image from file
Image_AlienPixMap anImageLoaded;
if (!anImageLoaded.Load (theFilePath))
{
const int nbbytes = width * height * 3;
GLubyte *data = new GLubyte[nbbytes];
GLubyte *pdata = data;
Standard_Integer i, j;
for ( j = height - 1; j >= 0; j-- )
for ( i = 0; i < width; i++ )
{
const Quantity_Color &color = image->PixelColor( i, j );
*pdata++ = (GLubyte)( 255 * color.Red() );
*pdata++ = (GLubyte)( 255 * color.Green() );
*pdata++ = (GLubyte)( 255 * color.Blue() );
}
glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
GLuint texture = 0;
glGenTextures( 1, &texture );
glBindTexture( GL_TEXTURE_2D, texture );
/* Create MipMapped Texture */
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
gluBuild2DMipmaps( GL_TEXTURE_2D, 3/*4*/, width, height, GL_RGB, GL_UNSIGNED_BYTE, data );
delete[] data;
myBgTexture.TexId = texture;
myBgTexture.Width = width;
myBgTexture.Height = height;
myBgTexture.Style = AFillStyle;
return;
}
Image_PixMap anImage;
if (anImageLoaded.RowExtraBytes() == 0 &&
(anImageLoaded.Format() == Image_PixMap::ImgRGB
|| anImageLoaded.Format() == Image_PixMap::ImgRGB32
|| anImageLoaded.Format() == Image_PixMap::ImgRGBA))
{
anImage.InitWrapper (anImageLoaded.Format(), anImageLoaded.ChangeData(),
anImageLoaded.SizeX(), anImageLoaded.SizeY(), anImageLoaded.SizeRowBytes());
}
else
{
// convert image to RGB format
if (!anImage.InitTrash (Image_PixMap::ImgRGB, anImageLoaded.SizeX(), anImageLoaded.SizeY()))
{
return;
}
anImage.SetTopDown (false);
Image_PixMapData<Image_ColorRGB>& aDataNew = anImage.EditData<Image_ColorRGB>();
Quantity_Color aSrcColor;
for (Standard_Size aRow = 0; aRow < anImage.SizeY(); ++aRow)
{
for (Standard_Size aCol = 0; aCol < anImage.SizeX(); ++aCol)
{
aSrcColor = anImageLoaded.PixelColor (aCol, aRow);
Image_ColorRGB& aColor = aDataNew.ChangeValue (aRow, aCol);
aColor.r() = int(255.0 * aSrcColor.Red());
aColor.g() = int(255.0 * aSrcColor.Green());
aColor.b() = int(255.0 * aSrcColor.Blue());
}
}
anImageLoaded.Clear();
}
// create MipMapped texture
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
GLuint aTextureId = 0;
glGenTextures (1, &aTextureId);
glBindTexture (GL_TEXTURE_2D, aTextureId);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
const GLenum aDataFormat = (anImage.Format() == Image_PixMap::ImgRGB) ? GL_RGB : GL_RGBA;
gluBuild2DMipmaps (GL_TEXTURE_2D, 3/*4*/,
GLint(anImage.SizeX()), GLint(anImage.SizeY()),
aDataFormat, GL_UNSIGNED_BYTE, anImage.Data());
myBgTexture.TexId = aTextureId;
myBgTexture.Width = (Standard_Integer )anImage.SizeX();
myBgTexture.Height = (Standard_Integer )anImage.SizeY();
myBgTexture.Style = theFillStyle;
}
/*----------------------------------------------------------------------*/
@ -1509,7 +1532,7 @@ void OpenGl_View::SetBackgroundGradientType (const Aspect_GradientFillMethod ATy
//=======================================================================
//function : AddZLayer
//purpose :
//purpose :
//=======================================================================
void OpenGl_View::AddZLayer (const Standard_Integer theLayerId)
@ -1519,7 +1542,7 @@ void OpenGl_View::AddZLayer (const Standard_Integer theLayerId)
//=======================================================================
//function : RemoveZLayer
//purpose :
//purpose :
//=======================================================================
void OpenGl_View::RemoveZLayer (const Standard_Integer theLayerId)
@ -1529,7 +1552,7 @@ void OpenGl_View::RemoveZLayer (const Standard_Integer theLayerId)
//=======================================================================
//function : DisplayStructure
//purpose :
//purpose :
//=======================================================================
void OpenGl_View::DisplayStructure (const OpenGl_Structure *theStructure,
@ -1541,7 +1564,7 @@ void OpenGl_View::DisplayStructure (const OpenGl_Structure *theStructure,
//=======================================================================
//function : EraseStructure
//purpose :
//purpose :
//=======================================================================
void OpenGl_View::EraseStructure (const OpenGl_Structure *theStructure)