{

switch (blendFactor)

{

default:

case cpp3ds::BlendMode::Zero: return GL_ZERO;

case cpp3ds::BlendMode::One: return GL_ONE;

case cpp3ds::BlendMode::SrcColor: return GL_SRC_COLOR;

case cpp3ds::BlendMode::OneMinusSrcColor: return GL_ONE_MINUS_SRC_COLOR;

case cpp3ds::BlendMode::DstColor: return GL_DST_COLOR;

case cpp3ds::BlendMode::OneMinusDstColor: return GL_ONE_MINUS_DST_COLOR;

case cpp3ds::BlendMode::SrcAlpha: return GL_SRC_ALPHA;

case cpp3ds::BlendMode::OneMinusSrcAlpha: return GL_ONE_MINUS_SRC_ALPHA;

case cpp3ds::BlendMode::DstAlpha: return GL_DST_ALPHA;

case cpp3ds::BlendMode::OneMinusDstAlpha: return GL_ONE_MINUS_DST_ALPHA;

}

{

switch (blendEquation)

{

default:

case cpp3ds::BlendMode::Add: return GL_FUNC_ADD;

case cpp3ds::BlendMode::Subtract: return GL_FUNC_SUBTRACT;

}

{

static cpp3ds::Uint64 id = 1;

static cpp3ds::Mutex mutex;

cpp3ds::Lock lock(mutex);

return id++;

m_defaultView (),

m_view (NULL),

m_cache (),

m_depthTest (false),

m_clearDepth (false),

m_defaultShader (NULL),

m_currentNonLegacyShader(NULL),

m_lastNonLegacyShader (NULL),

m_id (getUniqueId()),

m_previousViewport (-1, -1, -1, -1),

m_previousClearColor (0, 0, 0, 0)

{

m_cache.vertexCache = new Vertex[StatesCache::VertexCacheSize];

m_cache.glStatesSet = false;

Light::increaseLightReferences();

{

if (activate(true))

{

// Unbind texture to fix RenderTexture preventing clear

applyTexture(NULL);

if (color != m_previousClearColor)

{

#ifdef EMULATION

glCheck(glClearColor(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f));

#else

// Use glClearColorIiEXT to avoid unnecessary float conversion

glCheck(glClearColorIiEXT(color.r, color.g, color.b, color.a));

#endif

m_previousClearColor = color;

}

glCheck(glClear(GL_COLOR_BUFFER_BIT | (m_clearDepth ? GL_DEPTH_BUFFER_BIT : 0)));

}

{

m_depthTest = enable;

if(enable) {

glCheck(glEnable(GL_DEPTH_TEST));

} else {

glCheck(glDisable(GL_DEPTH_TEST));

}

{

float width = static_cast<float>(getSize().x);

float height = static_cast<float>(getSize().y);

const FloatRect& viewport = view.getViewport();

return IntRect(static_cast<int>(0.5f + width * viewport.left),

static_cast<int>(0.5f + height * viewport.top),

static_cast<int>(0.5f + width * viewport.width),

static_cast<int>(0.5f + height * viewport.height));

{

// First, convert from viewport coordinates to homogeneous coordinates

Vector2f normalized;

IntRect viewport = getViewport(view);

normalized.x = -1.f + 2.f * (point.x - viewport.left) / viewport.width;

normalized.y = 1.f - 2.f * (point.y - viewport.top) / viewport.height;

// Then transform by the inverse of the view matrix

return view.getInverseTransform().transformPoint(normalized);

{

// First, transform the point by the modelview and projection matrix

Vector3f normalized = (view.getTransform() * view.getViewTransform()).transformPoint(point);

// Then convert to viewport coordinates

Vector2i pixel;

IntRect viewport = getViewport(view);

pixel.x = static_cast<int>(( normalized.x + 1.f) / 2.f * viewport.width + viewport.left);

pixel.y = static_cast<int>((-normalized.y + 1.f) / 2.f * viewport.height + viewport.top);

return pixel;

{

// Nothing to draw?

if (!buffer.getVertexCount())

return;

draw(&buffer.m_vertices[0], buffer.getVertexCount(), buffer.m_primitiveType, states);

return;

if (activate(true))

{

// First set the persistent OpenGL states if it's the very first call

if (!m_cache.glStatesSet)

resetGLStates();

// Track if we need to set uniforms again for current shader

bool shaderChanged = false;

bool previousShaderWarnSetting = true;

applyTransform(states.transform);

// Apply the view

if (shaderChanged || m_cache.viewChanged)

applyCurrentView();

// Apply the blend mode

if (states.blendMode != m_cache.lastBlendMode)

applyBlendMode(states.blendMode);

// Apply the texture

Uint64 textureId = states.texture ? states.texture->m_cacheId : 0;

if (shaderChanged || (textureId != m_cache.lastTextureId))

applyTexture(states.texture);

// Apply the shader

// Find the OpenGL primitive type

static const GLenum modes[] = {GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN};

GLenum mode = modes[buffer.getPrimitiveType()];

// Setup the pointers to the vertices' components

if (!m_defaultShader)

{

#ifdef EMULATION

// Apply the vertex buffer

Uint64 vertexBufferId = buffer.m_cacheId;

if (vertexBufferId != m_cache.lastVertexBufferId)

applyVertexBuffer(&buffer);

glCheck(glVertexPointer(3, GL_FLOAT, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, position))));

glCheck(glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, color))));

glCheck(glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, texCoords))));

glCheck(glNormalPointer(GL_FLOAT, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, normal))));

#else

// Temorary workaround until gl3ds can get VAO gl*Pointer functions working

u32 bufferOffsets[] = {0};

u64 bufferPermutations[] = {0x3210};

u8 bufferAttribCounts[] = {4};

GPU_SetAttributeBuffers(

4, // number of attributes

(u32 *) osConvertVirtToPhys((u32) &buffer.m_vertices[0]),

GPU_ATTRIBFMT(0, 3, GPU_FLOAT) | GPU_ATTRIBFMT(1, 4, GPU_UNSIGNED_BYTE) |

GPU_ATTRIBFMT(2, 2, GPU_FLOAT) | GPU_ATTRIBFMT(3, 3, GPU_FLOAT),

0xFF8, //0b1100

0x3210,

1, //number of buffers

bufferOffsets,

bufferPermutations,

bufferAttribCounts // number of attributes for each buffer

);

#endif

// Draw the primitives

glCheck(glDrawArrays(mode, 0, buffer.getVertexCount()));

}

else

{

Light::addLightsToShader(*m_currentNonLegacyShader);

unsigned int arrayObject = 0;

bool newArray = true;

bool needUpload = false;

if (VertexBuffer::hasVertexArrayObjects())

{

// Lookup the current context (id, shader id) in the VertexBuffer

std::pair<Uint64, Uint64> contextIdentifier(m_id, m_currentNonLegacyShader->m_id);

VertexBuffer::ArrayObjects::iterator arrayObjectIter = buffer.m_arrayObjects.find(contextIdentifier);

if (arrayObjectIter == buffer.m_arrayObjects.end())

{

// VertexBuffer doesn't have a VAO in this context

// Create a new VAO

glCheck(glGenVertexArrays(1, &arrayObject));

// Register the VAO with the VertexBuffer

buffer.m_arrayObjects[contextIdentifier] = arrayObject;

// Mark the VAO age as 0

m_arrayAgeCount[arrayObject] = 0;

}

else

{

// VertexBuffer has/had a VAO in this context

// Grab the VAO identifier from the VertexBuffer

arrayObject = arrayObjectIter->second;

// Still need to check if it still exists

ArrayAgeCount::iterator arrayAge = m_arrayAgeCount.find(arrayObject);

if (arrayAge != m_arrayAgeCount.end())

{

// VAO still exists in this context

newArray = false;

// Check if the VertexBuffer data needs to be re-uploaded

needUpload = buffer.m_needUpload;

// Mark the VAO age as 0

arrayAge->second = 0;

}

else

{

// VAO needs to be recreated in this context

// Create a new VAO

glCheck(glGenVertexArrays(1, &arrayObject));

// Register the VAO with the VertexBuffer

arrayObjectIter->second = arrayObject;

// Mark the VAO age as 0

m_arrayAgeCount[arrayObject] = 0;

}

}

glBindVertexArray(arrayObject);

// Maximum array object age in draw calls before being purged

// If an array object was not used to draw this many

// calls, it will be considered expired and purged

// from the context owned by this RenderTarget

const static unsigned int maxArrayObjectAge = 10000;

// Increment age counters and purge all expired VAOs

for (ArrayAgeCount::iterator arrayAge = m_arrayAgeCount.begin(); arrayAge != m_arrayAgeCount.end();)

{

arrayAge->second++;

if (arrayAge->second > maxArrayObjectAge)

{

glCheck(glDeleteVertexArrays(1, &(arrayAge->first)));

m_arrayAgeCount.erase(arrayAge++);

continue;

}

++arrayAge;

}

}

int vertexLocation = -1;

int colorLocation = -1;

int texCoordLocation = -1;

int normalLocation = -1;

// If we are creating a new array object or buffer data

// needs to be re-uploaded, we need to rebind even if

// it is still currently bound

if (newArray || needUpload)

{

// Apply the vertex buffer

Uint64 vertexBufferId = buffer.m_cacheId;

applyVertexBuffer(&buffer);

}

if (newArray)

{

vertexLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_Vertex");

colorLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_Color");

texCoordLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_MultiTexCoord0");

normalLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_Normal");

if (vertexLocation >= 0)

{

glCheck(glEnableVertexAttribArray(vertexLocation));

glCheck(glVertexAttribPointer(vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, position))));

}

if (colorLocation >= 0)

{

glCheck(glEnableVertexAttribArray(colorLocation));

glCheck(glVertexAttribPointer(colorLocation, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, color))));

}

if (texCoordLocation >= 0)

{

glCheck(glEnableVertexAttribArray(texCoordLocation));

glCheck(glVertexAttribPointer(texCoordLocation, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, texCoords))));

}

if (normalLocation >= 0)

{

glCheck(glEnableVertexAttribArray(normalLocation));

glCheck(glVertexAttribPointer(normalLocation, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), reinterpret_cast<void*>(offsetof(Vertex, normal))));

}

}

// Draw the primitives

glCheck(glDrawArrays(mode, 0, buffer.getVertexCount()));

if (arrayObject)

glBindVertexArray(0);

if (vertexLocation >= 0)

glCheck(glDisableVertexAttribArray(vertexLocation));

if (colorLocation >= 0)

glCheck(glDisableVertexAttribArray(colorLocation));

if (texCoordLocation >= 0)

glCheck(glDisableVertexAttribArray(texCoordLocation));

if (normalLocation >= 0)

glCheck(glDisableVertexAttribArray(normalLocation));

}

// Unbind the shader, if any was bound in legacy mode

}

PrimitiveType type, const RenderStates& states)

{

// Nothing to draw?

if (!vertices || (vertexCount == 0))

return;

// Vertices allocated in the stack (common) can't be converted to physical address

#ifndef EMULATION

if (osConvertVirtToPhys((u32)vertices) == 0)

{

err() << "RenderTarget::draw() called with vertex array in inaccessible memory space." << std::endl;

return;

}

#endif

if (activate(true))

{

// First set the persistent OpenGL states if it's the very first call

if (!m_cache.glStatesSet)

resetGLStates();

// Track if we need to set uniforms again for current shader

bool shaderChanged = false;

bool previousShaderWarnSetting = true;

// Check if the vertex count is low enough so that we can pre-transform them

bool useVertexCache = (vertexCount <= StatesCache::VertexCacheSize);

if (useVertexCache)

{

// Pre-transform the vertices and store them into the vertex cache

for (unsigned int i = 0; i < vertexCount; ++i)

{

Vertex& vertex = m_cache.vertexCache[i];

vertex.position = states.transform * vertices[i].position;

vertex.color = vertices[i].color;

vertex.texCoords = vertices[i].texCoords;

}

// Since vertices are transformed, we must use an identity transform to render them

if (!m_cache.useVertexCache)

applyTransform(Transform::Identity);

}

else

{

applyTransform(states.transform);

}

// Apply the view

if (shaderChanged || m_cache.viewChanged)

applyCurrentView();

// Apply the blend mode

if (states.blendMode != m_cache.lastBlendMode)

applyBlendMode(states.blendMode);

// Apply the texture

Uint64 textureId = states.texture ? states.texture->m_cacheId : 0;

if (shaderChanged || (textureId != m_cache.lastTextureId))

applyTexture(states.texture);

// Apply the shader

// Unbind any bound vertex buffer

if (m_cache.lastVertexBufferId)

applyVertexBuffer(NULL);

// If we pre-transform the vertices, we must use our internal vertex cache

if (useVertexCache)

{

// ... and if we already used it previously, we don't need to set the pointers again

if (!m_cache.useVertexCache)

vertices = m_cache.vertexCache;

else

vertices = NULL;

}

// Find the OpenGL primitive type

static const GLenum modes[] = {GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN};

GLenum mode = modes[type];

// Setup the pointers to the vertices' components

if (!m_defaultShader)

{

if (vertices) {

#ifdef EMULATION

const char* data = reinterpret_cast<const char*>(vertices);

glCheck(glVertexPointer(3, GL_FLOAT, sizeof(Vertex), data + offsetof(Vertex, position)));

glCheck(glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex), data + offsetof(Vertex, color)));

glCheck(glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), data + offsetof(Vertex, texCoords)));

glCheck(glNormalPointer(GL_FLOAT, sizeof(Vertex), data + offsetof(Vertex, normal)));

#else

// Temorary workaround until gl3ds can get VAO gl*Pointer functions working

u32 bufferOffsets[] = {0};

u64 bufferPermutations[] = {0x3210};

u8 bufferAttribCounts[] = {4};

GPU_SetAttributeBuffers(

4, // number of attributes

(u32 *) osConvertVirtToPhys((u32) vertices),

GPU_ATTRIBFMT(0, 3, GPU_FLOAT) | GPU_ATTRIBFMT(1, 4, GPU_UNSIGNED_BYTE) |

GPU_ATTRIBFMT(2, 2, GPU_FLOAT) | GPU_ATTRIBFMT(3, 3, GPU_FLOAT),

0xFFF << 4, //0b1100

0x3210,

1, //number of buffers

bufferOffsets,

bufferPermutations,

bufferAttribCounts // number of attributes for each buffer

);

#endif

}

// Draw the primitives

glCheck(glDrawArrays(mode, 0, vertexCount));

} else {

Light::addLightsToShader(*m_currentNonLegacyShader);

int vertexLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_Vertex");

int colorLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_Color");

int texCoordLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_MultiTexCoord0");

int normalLocation = m_currentNonLegacyShader->getVertexAttributeLocation("sf_Normal");

const char* data = reinterpret_cast<const char*>(vertices);

if (vertexLocation >= 0) {

glCheck(glEnableVertexAttribArray(vertexLocation));

glCheck(glVertexAttribPointer(vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), data + offsetof(Vertex, position)));

}

if (colorLocation >= 0) {

glCheck(glEnableVertexAttribArray(colorLocation));

glCheck(glVertexAttribPointer(colorLocation, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), data + offsetof(Vertex, color)));

}

if (texCoordLocation >= 0) {

glCheck(glEnableVertexAttribArray(texCoordLocation));

glCheck(glVertexAttribPointer(texCoordLocation, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), data + offsetof(Vertex, texCoords)));

}

if (normalLocation >= 0) {

glCheck(glEnableVertexAttribArray(normalLocation));

glCheck(glVertexAttribPointer(normalLocation, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), data + offsetof(Vertex, normal)));

}

// Draw the primitives

glCheck(glDrawArrays(mode, 0, vertexCount));

if (vertexLocation >= 0)

glCheck(glDisableVertexAttribArray(vertexLocation));

if (colorLocation >= 0)

glCheck(glDisableVertexAttribArray(colorLocation));

if (texCoordLocation >= 0)

glCheck(glDisableVertexAttribArray(texCoordLocation));

if (normalLocation >= 0)

glCheck(glDisableVertexAttribArray(normalLocation));

}

// Unbind the shader, if any was bound in legacy mode

// Update the cache

m_cache.useVertexCache = useVertexCache;

}

{

if (activate(true))

{

#ifdef CPP3DS_DEBUG

// make sure that the user didn't leave an unchecked OpenGL error

GLenum error = glGetError();

if (error != GL_NO_ERROR)

{

err() << "OpenGL error (" << error << ") detected in user code, "

<< "you should check for errors with glGetError()"

<< std::endl;

}

#endif

glCheck(glPushAttrib(GL_ALL_ATTRIB_BITS));

if (!m_defaultShader)

{

glCheck(glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS));

glCheck(glMatrixMode(GL_MODELVIEW));

glCheck(glPushMatrix());

glCheck(glMatrixMode(GL_PROJECTION));

glCheck(glPushMatrix());

glCheck(glMatrixMode(GL_TEXTURE));

glCheck(glPushMatrix());

}

}

resetGLStates();

{

if (activate(true))

{

if (m_defaultShader)

applyShader(NULL);

if (!m_defaultShader)

{

glCheck(glMatrixMode(GL_PROJECTION));

glCheck(glPopMatrix());

glCheck(glMatrixMode(GL_MODELVIEW));

glCheck(glPopMatrix());

glCheck(glMatrixMode(GL_TEXTURE));

glCheck(glPopMatrix());

glCheck(glPopClientAttrib());

}

glCheck(glPopAttrib());

}

{

// Check here to make sure a context change does not happen after activate(true)

bool shaderAvailable = Shader::isAvailable();

if (activate(true))

{

// Make sure that the texture unit which is active is the number 0

if (GLEXT_multitexture)

{

glCheck(GLEXT_glClientActiveTexture(GLEXT_GL_TEXTURE0));

glCheck(GLEXT_glActiveTexture(GLEXT_GL_TEXTURE0));

}

// Define the default OpenGL states

glCheck(glDisable(GL_LIGHTING));

if(!m_depthTest)

glCheck(glDisable(GL_DEPTH_TEST));

glCheck(glDisable(GL_ALPHA_TEST));

glCheck(glEnable(GL_CULL_FACE));

glCheck(glEnable(GL_BLEND));

glCheck(glMatrixMode(GL_MODELVIEW));

glCheck(glDepthFunc(GL_GEQUAL));

glCheck(glClearDepth(0.f));

glCheck(glDepthRangef(1.f, 0.f));

if (!m_defaultShader)

{

glCheck(glEnable(GL_TEXTURE_2D));

glCheck(glEnable(GL_COLOR_MATERIAL));

glCheck(glEnable(GL_NORMALIZE));

glCheck(glMatrixMode(GL_MODELVIEW));

glCheck(glEnableClientState(GL_VERTEX_ARRAY));

glCheck(glEnableClientState(GL_COLOR_ARRAY));

glCheck(glEnableClientState(GL_TEXTURE_COORD_ARRAY));

glCheck(glEnableClientState(GL_NORMAL_ARRAY));

}

glCheck(glPolygonMode(GL_FRONT_AND_BACK, GL_FILL));

m_cache.glStatesSet = true;

// Apply the default SFML states

applyBlendMode(BlendAlpha);

applyTransform(Transform::Identity);

applyTexture(NULL);

if (shaderAvailable)

{

if (!m_defaultShader)

applyShader(NULL);

else

applyShader(m_defaultShader);

}

if (VertexBuffer::isAvailable())

applyVertexBuffer(NULL);

m_cache.useVertexCache = false;

// Set the default view

setView(m_defaultView);

}

{

// Setup the default and current views

m_defaultView.reset(FloatRect(0, 0, static_cast<float>(getSize().x), static_cast<float>(getSize().y)));

delete m_view;

m_view = new View(m_defaultView);

// Set GL states only on first draw, so that we don't pollute user's states

m_cache.glStatesSet = false;

// Try to set up non-legacy pipeline if available

{

// Set the viewport

IntRect viewport = getViewport(*m_view);

if (viewport != m_previousViewport)

{

int top = getSize().y - (viewport.top + viewport.height);

glCheck(glViewport(viewport.left, top, viewport.width, viewport.height));

m_previousViewport = viewport;

}

if (m_defaultShader)

{

const Shader* shader = NULL;

if (m_currentNonLegacyShader)

shader = m_currentNonLegacyShader;

else

shader = m_defaultShader;

shader->setParameter("sf_ProjectionMatrix", m_view->getTransform());

shader->setParameter("sf_ViewMatrix", m_view->getViewTransform());

shader->setParameter("sf_ViewerPosition", m_view->getPosition());

}

else

{

// Set the projection matrix

glCheck(glMatrixMode(GL_PROJECTION));

glCheck(glLoadMatrixf(m_view->getTransform().getMatrix()));

// Go back to model-view mode

glCheck(glMatrixMode(GL_MODELVIEW));

}

m_cache.viewChanged = false;

{

// Apply the blend mode

glCheck(glBlendFuncSeparate(

factorToGlConstant(mode.colorSrcFactor), factorToGlConstant(mode.colorDstFactor),

factorToGlConstant(mode.alphaSrcFactor), factorToGlConstant(mode.alphaDstFactor)));

glCheck(glBlendEquationSeparate(

equationToGlConstant(mode.colorEquation),

equationToGlConstant(mode.alphaEquation)));

m_cache.lastBlendMode = mode;

{

if (m_defaultShader)

{

const Shader* shader = NULL;

if (m_currentNonLegacyShader)

shader = m_currentNonLegacyShader;

else

shader = m_defaultShader;

shader->setParameter("sf_ModelMatrix", transform);

const float* modelMatrix = transform.getMatrix();

Transform normalMatrix(modelMatrix[0], modelMatrix[4], modelMatrix[8], 0.f,

modelMatrix[1], modelMatrix[5], modelMatrix[9], 0.f,

modelMatrix[2], modelMatrix[6], modelMatrix[10], 0.f,

0.f, 0.f, 0.f, 1.f);

if (Light::isLightingEnabled())

shader->setParameter("sf_NormalMatrix", normalMatrix.getInverse().getTranspose());

}

else

// No need to call glMatrixMode(GL_MODELVIEW), it is always the

// current mode (for optimization purpose, since it's the most used)

glCheck(glLoadMatrixf((m_view->getViewTransform() * transform).getMatrix()));

{

if (!m_defaultShader)

// No need to call glMatrixMode(GL_MODELVIEW), it is always the

// current mode (for optimization purpose, since it's the most used)

glCheck(glLoadMatrixf(m_view->getViewTransform().getMatrix()));

{

if (m_defaultShader)

{

const Shader* shader = NULL;

if (m_currentNonLegacyShader)

shader = m_currentNonLegacyShader;

else

shader = m_defaultShader;

float xScale = 1.f;

float yScale = 1.f;

float yFlip = 0.f;

if (texture)

{

// Setup scale factors that convert the range [0 .. size] to [0 .. 1]

xScale = 1.f / texture->m_actualSize.x;

yScale = 1.f / texture->m_actualSize.y;

// If pixels are flipped we must invert the Y axis

if (texture->m_pixelsFlipped)

{

yScale = -yScale;

yFlip = static_cast<float>(texture->m_size.y) / texture->m_actualSize.y;

}

Transform textureMatrix(xScale, 0.f, 0.f, 0.f,

0.f, yScale, 0.f, yFlip,

0.f, 0.f, 1.f, 0.f,

0.f, 0.f, 0.f, 1.f);

shader->setParameter("sf_TextureMatrix", textureMatrix);

shader->setParameter("sf_Texture0", *texture);

shader->setParameter("sf_TextureEnabled", 1);

}

else

shader->setParameter("sf_TextureEnabled", 0);

}

else

Texture::bind(texture, Texture::Pixels);

m_cache.lastTextureId = texture ? texture->m_cacheId : 0;