khanat-opennel-code/code/nel/src/3d/ps_quad.cpp
2010-06-10 11:50:19 +02:00

752 lines
22 KiB
C++

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std3d.h"
#include "nel/3d/ps_quad.h"
#include "nel/3d/ps_macro.h"
#include "nel/3d/driver.h"
#include "nel/3d/ps_attrib_maker.h"
#include "nel/3d/texture_grouped.h"
#include "nel/3d/particle_system.h"
#include "nel/3d/ps_iterator.h"
namespace NL3D
{
///////////////////////////
// constant definition //
///////////////////////////
static const uint dotBufSize = 1024; // size used for point particles batching
////////////////////
// vertex buffers //
////////////////////
/// the various kind of vertex buffers we need for quads
CVertexBuffer CPSQuad::_VBPos;
CVertexBuffer CPSQuad::_VBPosCol;
CVertexBuffer CPSQuad::_VBPosTex1;
CVertexBuffer CPSQuad::_VBPosTex1Col;
CVertexBuffer CPSQuad::_VBPosTex1Anim;
CVertexBuffer CPSQuad::_VBPosTex1AnimCol;
//==========
CVertexBuffer CPSQuad::_VBPosTex1Tex2;
CVertexBuffer CPSQuad::_VBPosTex1ColTex2;
CVertexBuffer CPSQuad::_VBPosTex1AnimTex2;
CVertexBuffer CPSQuad::_VBPosTex1AnimColTex2;
//==========
CVertexBuffer CPSQuad::_VBPosTex1Tex2Anim;
CVertexBuffer CPSQuad::_VBPosTex1ColTex2Anim;
CVertexBuffer CPSQuad::_VBPosTex1AnimTex2Anim;
CVertexBuffer CPSQuad::_VBPosTex1AnimColTex2Anim;
/// tmp : ram
CVertexBuffer RAMVBPos;
CVertexBuffer RAMVBPosCol;
CVertexBuffer RAMVBPosTex1;
CVertexBuffer RAMVBPosTex1Col;
CVertexBuffer RAMVBPosTex1Anim;
CVertexBuffer RAMVBPosTex1AnimCol;
//==========
CVertexBuffer RAMVBPosTex1Tex2;
CVertexBuffer RAMVBPosTex1ColTex2;
CVertexBuffer RAMVBPosTex1AnimTex2;
CVertexBuffer RAMVBPosTex1AnimColTex2;
//==========
CVertexBuffer RAMVBPosTex1Tex2Anim;
CVertexBuffer RAMVBPosTex1ColTex2Anim;
CVertexBuffer RAMVBPosTex1AnimTex2Anim;
CVertexBuffer RAMVBPosTex1AnimColTex2Anim;
CVertexBuffer * const CPSQuad::_VbTab[] =
{
// tex1 only
&_VBPos, &_VBPosCol, &_VBPosTex1, &_VBPosTex1Col,
NULL, NULL, &_VBPosTex1Anim, &_VBPosTex1AnimCol,
// tex1 & tex2
NULL, NULL, &_VBPosTex1Tex2, &_VBPosTex1ColTex2,
NULL, NULL, &_VBPosTex1AnimTex2, &_VBPosTex1AnimColTex2,
// tex2 & !tex1 (invalid)
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
// tex2 & !tex1 (invalid)
// tex1 & tex2
NULL, NULL, &_VBPosTex1Tex2Anim, &_VBPosTex1ColTex2Anim,
NULL, NULL, &_VBPosTex1AnimTex2Anim, &_VBPosTex1AnimColTex2Anim,
};
CVertexBuffer * const RAMVbTab[] =
{
// tex1 only
&RAMVBPos, &RAMVBPosCol, &RAMVBPosTex1, &RAMVBPosTex1Col,
NULL, NULL, &RAMVBPosTex1Anim, &RAMVBPosTex1AnimCol,
// tex1 & tex2
NULL, NULL, &RAMVBPosTex1Tex2, &RAMVBPosTex1ColTex2,
NULL, NULL, &RAMVBPosTex1AnimTex2, &RAMVBPosTex1AnimColTex2,
// tex2 & !tex1 (invalid)
NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
// tex2 & !tex1 (invalid)
// tex1 & tex2
NULL, NULL, &RAMVBPosTex1Tex2Anim, &RAMVBPosTex1ColTex2Anim,
NULL, NULL, &RAMVBPosTex1AnimTex2Anim, &RAMVBPosTex1AnimColTex2Anim,
};
//////////////////////////////////
// CPSQuad implementation //
//////////////////////////////////
///==================================================================================
/// fill textures coordinates for a quad vb
static void SetupQuadVBTexCoords(CVertexBuffer &vb, uint texCoordSet)
{
NL_PS_FUNC(SetupQuadVBTexCoords)
nlassert(texCoordSet < 2);
CVertexBufferReadWrite vba;
vb.lock (vba);
// the size used for buffer can't be higher than quad buf size
// to have too large buffer will broke the cache
for (uint32 k = 0; k < CPSQuad::quadBufSize; ++k)
{
vba.setTexCoord(k * 4, texCoordSet, CUV(0, 0));
vba.setTexCoord(k * 4 + 1, texCoordSet, CUV(1, 0));
vba.setTexCoord(k * 4 + 2, texCoordSet, CUV(1, 1));
vba.setTexCoord(k * 4 + 3, texCoordSet, CUV(0, 1));
}
}
///==================================================================================
/// this static method init vertex buffers
void CPSQuad::initVertexBuffers()
{
NL_PS_FUNC(CPSQuad_initVertexBuffers)
for (uint k = 0; k < 32; ++k)
{
CVertexBuffer *vb = _VbTab[k];
if (vb) // valid vb ?
{
vb->setName("CPSQuad");
vb->setPreferredMemory(CVertexBuffer::AGPVolatile, true);
uint32 vf = CVertexBuffer::PositionFlag;
/// setup vertex format
if (k & (uint) VBCol) vf |= CVertexBuffer::PrimaryColorFlag;
if (k & (uint) VBTex || k & (uint) VBTexAnimated) vf |= CVertexBuffer::TexCoord0Flag;
if (k & (uint) VBTex2 || k & (uint) VBTex2Animated) vf |= CVertexBuffer::TexCoord1Flag;
vb->setVertexFormat(vf);
vb->setNumVertices(quadBufSize << 2);
if ((k & (uint) VBTex) && !(k & (uint) VBTexAnimated))
{
SetupQuadVBTexCoords(*vb, 0);
}
if ((k & (uint) VBTex2) && !(k & (uint) VBTex2Animated))
{
SetupQuadVBTexCoords(*vb, 1);
}
}
}
/*
for (uint k = 0; k < 32; ++k)
{
CVertexBuffer *vb = RAMVbTab[k];
if (vb) // valid vb ?
{
vb->setName("CPSQuadRAM");
vb->setPreferredMemory(CVertexBuffer::RAMPreferred, false);
uint32 vf = CVertexBuffer::PositionFlag;
/// setup vertex format
if (k & (uint) VBCol) vf |= CVertexBuffer::PrimaryColorFlag;
if (k & (uint) VBTex || k & (uint) VBTexAnimated) vf |= CVertexBuffer::TexCoord0Flag;
if (k & (uint) VBTex2 || k & (uint) VBTex2Animated) vf |= CVertexBuffer::TexCoord1Flag;
vb->setVertexFormat(vf);
vb->setNumVertices(quadBufSize << 2);
if ((k & (uint) VBTex) && !(k & (uint) VBTexAnimated))
{
SetupQuadVBTexCoords(*vb, 0);
}
if ((k & (uint) VBTex2) && !(k & (uint) VBTex2Animated))
{
SetupQuadVBTexCoords(*vb, 1);
}
}
}
*/
}
// tmp
//volatile bool TestWantAGPCPSQuad = true;
///==================================================================================
/// choose the vertex buffex that we need
CVertexBuffer &CPSQuad::getNeededVB(IDriver &drv)
{
NL_PS_FUNC(CPSQuad_getNeededVB)
uint flags = 0;
if (_ColorScheme) flags |= (uint) VBCol;
if (_TexGroup)
{
flags |= VBTex | VBTexAnimated;
}
else if (_Tex)
{
flags |= VBTex;
}
if (flags & VBTex)
{
/// check if multitexturing is enabled, and which texture are enabled and / or animated
if (CPSMultiTexturedParticle::isMultiTextureEnabled())
{
if (isAlternateTextureUsed(drv) && _AlternateTexture2)
{
if ((flags & VBTex) && (_TexScrollAlternate[0].x != 0 || _TexScrollAlternate[0].y != 0)) flags |= VBTexAnimated;
if (_AlternateOp != Decal && (_TexScrollAlternate[1].x != 0 || _TexScrollAlternate[1].y != 0))
{
flags |= VBTex2 | VBTex2Animated;
}
else
{
flags |= VBTex2;
}
}
else
{
if ((flags & VBTex) && (_TexScroll[0].x != 0 || _TexScroll[0].y != 0)) flags |= VBTexAnimated;
if (_Texture2)
{
if (_MainOp != Decal && (_TexScroll[1].x != 0 || _TexScroll[1].y != 0))
{
flags |= VBTex2 | VBTex2Animated;
}
else
{
flags |= VBTex2;
}
}
}
}
}
/*if (TestWantAGPCPSQuad)
{*/
nlassert((flags & ~VBFullMask) == 0); // check for overflow
nlassert(_VbTab[flags] != NULL);
return *(_VbTab[flags]); // get the vb
/*}
else
{
nlassert((flags & ~VBFullMask) == 0); // check for overflow
nlassert(RAMVbTab[flags] != NULL);
return *(RAMVbTab[flags]); // get the vb
}*/
}
///==================================================================================
CPSQuad::CPSQuad(CSmartPtr<ITexture> tex)
{
NL_PS_FUNC(CPSQuad_CPSQuad)
setTexture(tex);
init();
// we don't init the _IndexBuffer for now, as it will be when resize is called
if (CParticleSystem::getSerializeIdentifierFlag()) _Name = std::string("quad");
}
///==================================================================================
CPSQuad::~CPSQuad()
{
NL_PS_FUNC(CPSQuad_CPSQuadDtor)
}
///==================================================================================
uint32 CPSQuad::getNumWantedTris() const
{
NL_PS_FUNC(CPSQuad_getNumWantedTris)
nlassert(_Owner);
//return _Owner->getMaxSize() << 1;
return _Owner->getSize() << 1;
}
///==================================================================================
bool CPSQuad::hasTransparentFaces(void)
{
NL_PS_FUNC(CPSQuad_hasTransparentFaces)
return getBlendingMode() != CPSMaterial::alphaTest ;
}
///==================================================================================
bool CPSQuad::hasOpaqueFaces(void)
{
NL_PS_FUNC(CPSQuad_hasOpaqueFaces)
return !hasTransparentFaces();
}
///==================================================================================
void CPSQuad::init(void)
{
NL_PS_FUNC(CPSQuad_init)
_Mat.setLighting(false);
_Mat.setDoubleSided(true);
updateMatAndVbForColor();
updateMatAndVbForTexture();
}
///==================================================================================
void CPSQuad::updateMatAndVbForTexture(void)
{
NL_PS_FUNC(CPSQuad_updateMatAndVbForTexture)
if (CPSMultiTexturedParticle::isMultiTextureEnabled())
{
touch();
}
else
{
_Mat.setTexture(0, _TexGroup ? (ITexture *) _TexGroup : (ITexture *) _Tex);
}
}
///==================================================================================
bool CPSQuad::completeBBox(NLMISC::CAABBox &box) const
{
NL_PS_FUNC(CPSQuad_completeBBox)
if (!_SizeScheme)
{
CPSUtil::addRadiusToAABBox(box, _ParticleSize);
}
else
{
CPSUtil::addRadiusToAABBox(box, std::max(fabsf(_SizeScheme->getMaxValue()), fabsf(_SizeScheme->getMinValue())));
}
return true ;
}
///==================================================================================
void CPSQuad::resize(uint32 size)
{
NL_PS_FUNC(CPSQuad_resize)
nlassert(size < (1 << 16));
resizeSize(size);
resizeColor(size);
resizeTextureIndex(size);
}
//==============================================================
void CPSQuad::updateMatAndVbForColor(void)
{
NL_PS_FUNC(CPSQuad_updateMatAndVbForColor)
// no vb to setup, now..
/* if (!_ColorScheme)
{
_Mat.setColor(_Color);
}
else
{
_Mat.setColor(CRGBA::White);
} */
}
//==============================================================
void CPSQuad::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
NL_PS_FUNC(CPSQuad_serial)
sint ver = f.serialVersion(2);
CPSParticle::serial(f);
CPSSizedParticle::serialSizeScheme(f);
CPSColoredParticle::serialColorScheme(f);
CPSTexturedParticle::serialTextureScheme(f);
serialMaterial(f);
if (ver > 1)
{
CPSMultiTexturedParticle::serialMultiTex(f);
}
}
//==============================================================
// static func used to fill texture coordinates of quads, with global time
static void FillQuadCoords(uint8 *dest, uint stride, const NLMISC::CVector2f &speed, float time, uint num)
{
NL_PS_FUNC(FillQuadCoords)
if (!num) return;
const float topV = speed.y * time;
const float bottomV = topV + 1.f;
const float leftU = speed.x * time;
const float rightU = leftU + 1.f;
do
{
((NLMISC::CUV *) dest)->set(leftU, topV);
((NLMISC::CUV *) (dest + stride))->set(rightU, topV);
((NLMISC::CUV *) (dest + (stride << 1)))->set(rightU, bottomV);
((NLMISC::CUV *) (dest + (stride * 3)))->set(leftU, bottomV);
dest += stride << 2;
}
while (--num);
}
//==============================================================
// static func used to fill texture coordinates of quads, with local time
static void FillQuadCoordsLocalTime(uint8 *dest, uint stride, const NLMISC::CVector2f &speed, CPSLocated &srcLoc, uint startIndex, uint num, uint32 srcStep)
{
NL_PS_FUNC(FillQuadCoordsLocalTime)
if (!num) return;
if (srcStep == (1 << 16)) // step = 1.0 ?
{
TPSAttribTime::iterator timePt = srcLoc.getTime().begin() + startIndex;
do
{
const float topV = speed.y * *timePt;
const float bottomV = topV + 1.f;
const float leftU = speed.x * *timePt;
const float rightU = leftU + 1.f;
((NLMISC::CUV *) dest)->set(leftU, topV);
((NLMISC::CUV *) (dest + stride))->set(rightU, topV);
((NLMISC::CUV *) (dest + (stride << 1)))->set(rightU, bottomV);
((NLMISC::CUV *) (dest + (stride * 3)))->set(leftU, bottomV);
dest += stride << 2;
++timePt;
}
while (--num);
}
else
{
TIteratorTimeStep1616 timePt(srcLoc.getTime().begin(), startIndex, srcStep);
do
{
const float topV = speed.y * *timePt;
const float bottomV = topV + 1.f;
const float leftU = speed.x * *timePt;
const float rightU = leftU + 1.f;
((NLMISC::CUV *) dest)->set(leftU, topV);
((NLMISC::CUV *) (dest + stride))->set(rightU, topV);
((NLMISC::CUV *) (dest + (stride << 1)))->set(rightU, bottomV);
((NLMISC::CUV *) (dest + (stride * 3)))->set(leftU, bottomV);
dest += stride << 2;
++timePt;
}
while (--num);
}
}
//==============================================================
void CPSQuad::updateVbColNUVForRender(CVertexBuffer &vb, uint32 startIndex, uint32 size, uint32 srcStep, IDriver &drv)
{
NL_PS_FUNC(CPSQuad_updateVbColNUVForRender)
nlassert(_Owner);
if (!size) return;
CVertexBufferReadWrite vba;
vb.lock (vba);
if (_ColorScheme)
{
// compute the colors, each color is replicated 4 times
// todo hulud d3d vertex color RGBA / BGRA
_ColorScheme->make4(_Owner, startIndex, vba.getColorPointer(), vb.getVertexSize(), size, srcStep);
}
if (_TexGroup) // if it has a constant texture we are sure it has been setupped before...
{
sint32 textureIndex[quadBufSize];
const uint32 stride = vb.getVertexSize(), stride2 = stride << 1, stride3 = stride2 + stride, stride4 = stride2 << 1;
uint8 *currUV = (uint8 *) vba.getTexCoordPointer();
const sint32 *currIndex;
uint32 currIndexIncr;
if (_TextureIndexScheme)
{
currIndex = (sint32 *) _TextureIndexScheme->make(_Owner, startIndex, textureIndex, sizeof(sint32), size, true, srcStep);
currIndexIncr = 1;
}
else
{
currIndex = &_TextureIndex;
currIndexIncr = 0;
}
uint32 left = size;
while (left--)
{
// for now, we don't make texture index wrapping
const CTextureGrouped::TFourUV &uvGroup = _TexGroup->getUVQuad((uint32) *currIndex);
// copy the 4 uv's for this face
*(CUV *) currUV = uvGroup.uv0;
*(CUV *) (currUV + stride) = uvGroup.uv1;
*(CUV *) (currUV + stride2) = uvGroup.uv2;
*(CUV *) (currUV + stride3) = uvGroup.uv3;
// point the next face
currUV += stride4;
currIndex += currIndexIncr;
}
}
nlassert(_Owner && _Owner->getOwner());
const float date= (float) _Owner->getOwner()->getSystemDate();
/// todo: vertex program optimisation (& choose the vb accordingly)
if (CPSMultiTexturedParticle::isMultiTextureEnabled() && (_Tex || _TexGroup))
{
// perform tex1 animation if needed
if (!_TexGroup) // doesn't work with texGroup enabled
{
if (!isAlternateTextureUsed(drv) || !isAlternateTexEnabled() || !_AlternateTexture2)
{
if (_Tex && (_TexScroll[0].x != 0 || _TexScroll[0].y != 0))
{
// animation of texture 1 with main speed
if (!getUseLocalDate())
{
FillQuadCoords((uint8 *) vba.getTexCoordPointer(0, 0), vb.getVertexSize(), _TexScroll[0], date, size);
}
else
{
FillQuadCoordsLocalTime((uint8 *) vba.getTexCoordPointer(0, 0), vb.getVertexSize(), _TexScroll[0], *_Owner, startIndex, size, srcStep);
}
}
}
else
{
if (_Tex && (_TexScrollAlternate[0].x != 0 || _TexScrollAlternate[0].y != 0))
{
// animation of texture 1 with alternate speed
if (!getUseLocalDateAlt())
{
FillQuadCoords((uint8 *) vba.getTexCoordPointer(0, 0), vb.getVertexSize(), _TexScrollAlternate[0], date, size);
}
else
{
FillQuadCoordsLocalTime((uint8 *) vba.getTexCoordPointer(0, 0), vb.getVertexSize(), _TexScrollAlternate[0], *_Owner, startIndex, size, srcStep);
}
}
}
}
// perform tex2 animation if needed
if (!isAlternateTextureUsed(drv))
{
if (_Texture2 && (_TexScroll[1].x != 0 || _TexScroll[1].y != 0))
{
// animation of texture 2 with main speed
if (!getUseLocalDate())
{
FillQuadCoords((uint8 *) vba.getTexCoordPointer(0, 1), vb.getVertexSize(), _TexScroll[1], date, size);
}
else
{
FillQuadCoordsLocalTime((uint8 *) vba.getTexCoordPointer(0, 1), vb.getVertexSize(), _TexScroll[1], *_Owner, startIndex, size, srcStep);
}
}
}
else
{
if (_AlternateTexture2 && isAlternateTexEnabled() && (_TexScrollAlternate[1].x != 0 || _TexScrollAlternate[1].y != 0))
{
// animation of texture 2 with alternate speed
if (!getUseLocalDateAlt())
{
FillQuadCoords((uint8 *) vba.getTexCoordPointer(0, 1), vb.getVertexSize(), _TexScrollAlternate[1], date, size);
}
else
{
FillQuadCoordsLocalTime((uint8 *) vba.getTexCoordPointer(0, 1), vb.getVertexSize(), _TexScrollAlternate[1], *_Owner, startIndex, size, srcStep);
}
}
}
}
}
///==================================================================================
void CPSQuad::updateMatBeforeRendering(IDriver *drv, CVertexBuffer &vb)
{
NL_PS_FUNC(CPSQuad_updateMatBeforeRendering)
nlassert(_Owner && _Owner->getOwner());
CParticleSystem &ps = *(_Owner->getOwner());
vb.setUVRouting(0, 0);
vb.setUVRouting(1, 1); // default uv routing
if (isMultiTextureEnabled())
{
setupMaterial(_Tex, drv, _Mat, vb);
if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
{
_Mat.setColor(ps.getGlobalColorLighted());
}
else
{
_Mat.setColor(ps.getGlobalColor());
}
}
else
{
/// update the material if the global color of the system is variable
if (_ColorScheme != NULL &&
(ps.getColorAttenuationScheme() != NULL ||
ps.isUserColorUsed() ||
ps.getForceGlobalColorLightingFlag() ||
usesGlobalColorLighting()
)
)
{
if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
{
CPSMaterial::forceModulateConstantColor(true, ps.getGlobalColorLighted());
}
else
{
CPSMaterial::forceModulateConstantColor(true, ps.getGlobalColor());
}
}
else
{
forceModulateConstantColor(false);
NLMISC::CRGBA col;
if (ps.getForceGlobalColorLightingFlag() || usesGlobalColorLighting())
{
col.modulateFromColor(ps.getGlobalColorLighted(), _Color);
}
else if (ps.getColorAttenuationScheme() != NULL || ps.isUserColorUsed())
{
col.modulateFromColor(ps.getGlobalColor(), _Color);
}
else
{
col = _Color;
}
_Mat.setColor(col);
}
}
}
// *****************************************************************************************************
void CPSQuad::enumTexs(std::vector<NLMISC::CSmartPtr<ITexture> > &dest, IDriver &drv)
{
NL_PS_FUNC(CPSQuad_enumTexs)
CPSTexturedParticle::enumTexs(dest);
CPSMultiTexturedParticle::enumTexs(dest, drv);
}
// *****************************************************************************************************
void CPSQuad::setZBias(float value)
{
NL_PS_FUNC(CPSQuad_setZBias)
CPSMaterial::setZBias(value);
}
// *****************************************************************************************************
void CPSQuad::setTexture(CSmartPtr<ITexture> tex)
{
NL_PS_FUNC(CPSQuad_setTexture)
CPSTexturedParticle::setTexture(tex);
CPSMultiTexturedParticle::touch();
}
// *****************************************************************************************************
void CPSQuad::setTextureGroup(NLMISC::CSmartPtr<CTextureGrouped> texGroup)
{
NL_PS_FUNC(CPSQuad_setTextureGroup)
CPSTexturedParticle::setTextureGroup(texGroup);
CPSMultiTexturedParticle::touch();
}
// *****************************************************************************************************
void CPSQuad::setTexture2(ITexture *tex)
{
NL_PS_FUNC(CPSQuad_setTexture2)
CPSMultiTexturedParticle::setTexture2(tex);
}
// *****************************************************************************************************
void CPSQuad::setTexture2Alternate(ITexture *tex)
{
NL_PS_FUNC(CPSQuad_setTexture2Alternate)
CPSMultiTexturedParticle::setTexture2Alternate(tex);
}
// *****************************************************************************************************
void CPSQuad::updateTexWrapMode(IDriver &drv)
{
NL_PS_FUNC(CPSQuad_updateTexWrapMode)
if (isMultiTextureEnabled())
{
if (_Tex)
{
if (isAlternateTextureUsed(drv))
{
_Tex->setWrapS(_TexScroll[0].x == 0 ? ITexture::Clamp : ITexture::Repeat);
_Tex->setWrapT(_TexScroll[0].y == 0 ? ITexture::Clamp : ITexture::Repeat);
}
else
{
_Tex->setWrapS(_TexScrollAlternate[0].x == 0 ? ITexture::Clamp : ITexture::Repeat);
_Tex->setWrapT(_TexScrollAlternate[0].y == 0 ? ITexture::Clamp : ITexture::Repeat);
}
}
ITexture *tex2 = isAlternateTextureUsed(drv) ? getTexture2Alternate() : getTexture2();
if (tex2)
{
tex2->setWrapS(_TexScroll[1].x == 0 ? ITexture::Clamp : ITexture::Repeat);
tex2->setWrapT(_TexScroll[1].y == 0 ? ITexture::Clamp : ITexture::Repeat);
}
}
else
{
if (_Tex)
{
_Tex->setWrapS(ITexture::Clamp);
_Tex->setWrapT(ITexture::Clamp);
}
// nb for grouped texture we assume that no mipmapping is used, and that the border is black (or white for modulate material mode)
}
}
} // NL3D