void RAS_StorageIM::TexCoord(const RAS_TexVert &tv)
{
int unit;
if (GLEW_ARB_multitexture) {
for (unit = 0; unit < *m_texco_num; unit++) {
switch (m_texco[unit]) {
case RAS_IRasterizer::RAS_TEXCO_ORCO:
case RAS_IRasterizer::RAS_TEXCO_GLOB:
glMultiTexCoord3fvARB(GL_TEXTURE0_ARB + unit, tv.getXYZ());
break;
case RAS_IRasterizer::RAS_TEXCO_UV:
glMultiTexCoord2fvARB(GL_TEXTURE0_ARB + unit, tv.getUV(unit));
break;
case RAS_IRasterizer::RAS_TEXCO_NORM:
glMultiTexCoord3fvARB(GL_TEXTURE0_ARB + unit, tv.getNormal());
break;
case RAS_IRasterizer::RAS_TEXTANGENT:
glMultiTexCoord4fvARB(GL_TEXTURE0_ARB + unit, tv.getTangent());
break;
default:
break;
}
}
}
if (GLEW_ARB_vertex_program) {
for (unit = 0; unit < *m_attrib_num; unit++) {
switch (m_attrib[unit]) {
case RAS_IRasterizer::RAS_TEXCO_ORCO:
case RAS_IRasterizer::RAS_TEXCO_GLOB:
glVertexAttrib3fvARB(unit, tv.getXYZ());
break;
case RAS_IRasterizer::RAS_TEXCO_UV:
glVertexAttrib2fvARB(unit, tv.getUV(m_attrib_layer[unit]));
break;
case RAS_IRasterizer::RAS_TEXCO_NORM:
glVertexAttrib3fvARB(unit, tv.getNormal());
break;
case RAS_IRasterizer::RAS_TEXTANGENT:
glVertexAttrib4fvARB(unit, tv.getTangent());
break;
case RAS_IRasterizer::RAS_TEXCO_VCOL:
glVertexAttrib4ubvARB(unit, tv.getRGBA());
break;
default:
break;
}
}
}
}
void RAS_OpenGLRasterizer::IndexPrimitives_3DText(RAS_MeshSlot& ms,
class RAS_IPolyMaterial* polymat)
{
bool obcolor = ms.m_bObjectColor;
MT_Vector4& rgba = ms.m_RGBAcolor;
RAS_MeshSlot::iterator it;
const STR_String& mytext = ((CValue*)m_clientobject)->GetPropertyText("Text");
// handle object color
if (obcolor) {
glDisableClientState(GL_COLOR_ARRAY);
glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
}
else
glEnableClientState(GL_COLOR_ARRAY);
for (ms.begin(it); !ms.end(it); ms.next(it)) {
RAS_TexVert *vertex;
size_t i, j, numvert;
numvert = it.array->m_type;
if (it.array->m_type == RAS_DisplayArray::LINE) {
// line drawing, no text
glBegin(GL_LINES);
for (i=0; i<it.totindex; i+=2)
{
vertex = &it.vertex[it.index[i]];
glVertex3fv(vertex->getXYZ());
vertex = &it.vertex[it.index[i+1]];
glVertex3fv(vertex->getXYZ());
}
glEnd();
}
else {
// triangle and quad text drawing
for (i=0; i<it.totindex; i+=numvert)
{
float v[4][3];
int glattrib, unit;
for (j=0; j<numvert; j++) {
vertex = &it.vertex[it.index[i+j]];
v[j][0] = vertex->getXYZ()[0];
v[j][1] = vertex->getXYZ()[1];
v[j][2] = vertex->getXYZ()[2];
}
// find the right opengl attribute
glattrib = -1;
if (GLEW_ARB_vertex_program)
for (unit=0; unit<m_attrib_num; unit++)
if (m_attrib[unit] == RAS_TEXCO_UV)
glattrib = unit;
GPU_render_text(polymat->GetMTFace(), polymat->GetDrawingMode(), mytext, mytext.Length(), polymat->GetMCol(), v[0], v[1], v[2], v[3], glattrib);
ClearCachingInfo();
}
}
}
glDisableClientState(GL_COLOR_ARRAY);
}
PyObject *KX_MeshProxy::PyTransformUV(PyObject *args, PyObject *kwds)
{
int matindex;
PyObject *pymat;
int uvindex = -1;
int uvindex_from = -1;
bool ok = false;
MT_Matrix4x4 transform;
if (!PyArg_ParseTuple(args,"iO|iii:transformUV", &matindex, &pymat, &uvindex, &uvindex_from) ||
!PyMatTo(pymat, transform))
{
return NULL;
}
if (uvindex < -1 || uvindex > 1) {
PyErr_Format(PyExc_ValueError,
"mesh.transformUV(...): invalid uv_index %d", uvindex);
return NULL;
}
if (uvindex_from < -1 || uvindex_from > 1) {
PyErr_Format(PyExc_ValueError,
"mesh.transformUV(...): invalid uv_index_from %d", uvindex);
return NULL;
}
if (uvindex_from == uvindex) {
uvindex_from = -1;
}
/* transform mesh verts */
unsigned int mit_index = 0;
for (list<RAS_MeshMaterial>::iterator mit = m_meshobj->GetFirstMaterial();
(mit != m_meshobj->GetLastMaterial());
++mit, ++mit_index)
{
if (matindex == -1) {
/* always transform */
}
else if (matindex == mit_index) {
/* we found the right index! */
}
else {
continue;
}
RAS_MeshSlot *slot = mit->m_baseslot;
RAS_MeshSlot::iterator it;
ok = true;
for (slot->begin(it); !slot->end(it); slot->next(it)) {
size_t i;
for (i = it.startvertex; i < it.endvertex; i++) {
RAS_TexVert *vert = &it.vertex[i];
if (uvindex_from != -1) {
if (uvindex_from == 0) vert->SetUV(1, vert->getUV(0));
else vert->SetUV(0, vert->getUV(1));
}
switch (uvindex) {
case 0:
vert->TransformUV(0, transform);
break;
case 1:
vert->TransformUV(1, transform);
break;
case -1:
vert->TransformUV(0, transform);
vert->TransformUV(1, transform);
break;
}
}
}
/* if we set a material index, quit when done */
if (matindex == mit_index) {
break;
}
}
if (ok == false) {
PyErr_Format(PyExc_ValueError,
"mesh.transformUV(...): invalid material index %d", matindex);
return NULL;
}
m_meshobj->SetMeshModified(true);
Py_RETURN_NONE;
}
PyObject *KX_MeshProxy::PyTransform(PyObject *args, PyObject *kwds)
{
int matindex;
PyObject *pymat;
bool ok = false;
MT_Matrix4x4 transform;
if (!PyArg_ParseTuple(args,"iO:transform", &matindex, &pymat) ||
!PyMatTo(pymat, transform))
{
return NULL;
}
MT_Matrix4x4 ntransform = transform.inverse().transposed();
ntransform[0][3] = ntransform[1][3] = ntransform[2][3] = 0.0f;
/* transform mesh verts */
unsigned int mit_index = 0;
for (list<RAS_MeshMaterial>::iterator mit = m_meshobj->GetFirstMaterial();
(mit != m_meshobj->GetLastMaterial());
++mit, ++mit_index)
{
if (matindex == -1) {
/* always transform */
}
else if (matindex == mit_index) {
/* we found the right index! */
}
else {
continue;
}
RAS_MeshSlot *slot = mit->m_baseslot;
RAS_MeshSlot::iterator it;
ok = true;
for (slot->begin(it); !slot->end(it); slot->next(it)) {
size_t i;
for (i = it.startvertex; i < it.endvertex; i++) {
RAS_TexVert *vert = &it.vertex[i];
vert->Transform(transform, ntransform);
}
}
/* if we set a material index, quit when done */
if (matindex == mit_index) {
break;
}
}
if (ok == false) {
PyErr_Format(PyExc_ValueError,
"mesh.transform(...): invalid material index %d", matindex);
return NULL;
}
m_meshobj->SetMeshModified(true);
Py_RETURN_NONE;
}
void RAS_StorageIM::IndexPrimitivesInternal(RAS_MeshSlot& ms, bool multi)
{
bool obcolor = ms.m_bObjectColor;
bool wireframe = m_drawingmode <= RAS_IRasterizer::KX_WIREFRAME;
MT_Vector4& rgba = ms.m_RGBAcolor;
RAS_MeshSlot::iterator it;
if (ms.m_pDerivedMesh) {
// mesh data is in derived mesh,
current_bucket = ms.m_bucket;
current_polymat = current_bucket->GetPolyMaterial();
current_ms = &ms;
current_mesh = ms.m_mesh;
current_wireframe = wireframe;
// MCol *mcol = (MCol*)ms.m_pDerivedMesh->getFaceDataArray(ms.m_pDerivedMesh, CD_MCOL); /* UNUSED */
// handle two-side
if (current_polymat->GetDrawingMode() & RAS_IRasterizer::KX_BACKCULL)
this->SetCullFace(true);
else
this->SetCullFace(false);
if (current_polymat->GetFlag() & RAS_BLENDERGLSL) {
// GetMaterialIndex return the original mface material index,
// increment by 1 to match what derived mesh is doing
current_blmat_nr = current_polymat->GetMaterialIndex()+1;
// For GLSL we need to retrieve the GPU material attribute
Material* blmat = current_polymat->GetBlenderMaterial();
Scene* blscene = current_polymat->GetBlenderScene();
if (!wireframe && blscene && blmat)
GPU_material_vertex_attributes(GPU_material_from_blender(blscene, blmat), ¤t_gpu_attribs);
else
memset(¤t_gpu_attribs, 0, sizeof(current_gpu_attribs));
// DM draw can mess up blending mode, restore at the end
int current_blend_mode = GPU_get_material_alpha_blend();
ms.m_pDerivedMesh->drawFacesGLSL(ms.m_pDerivedMesh, CheckMaterialDM);
GPU_set_material_alpha_blend(current_blend_mode);
} else {
//ms.m_pDerivedMesh->drawMappedFacesTex(ms.m_pDerivedMesh, CheckTexfaceDM, mcol);
current_blmat_nr = current_polymat->GetMaterialIndex();
current_image = current_polymat->GetBlenderImage();
ms.m_pDerivedMesh->drawFacesTex(ms.m_pDerivedMesh, CheckTexDM, NULL, NULL, DM_DRAW_USE_ACTIVE_UV);
}
return;
}
// iterate over display arrays, each containing an index + vertex array
for (ms.begin(it); !ms.end(it); ms.next(it)) {
RAS_TexVert *vertex;
size_t i, j, numvert;
numvert = it.array->m_type;
if (it.array->m_type == RAS_DisplayArray::LINE) {
// line drawing
glBegin(GL_LINES);
for (i = 0; i < it.totindex; i += 2)
{
vertex = &it.vertex[it.index[i]];
glVertex3fv(vertex->getXYZ());
vertex = &it.vertex[it.index[i+1]];
glVertex3fv(vertex->getXYZ());
}
glEnd();
}
else {
// triangle and quad drawing
if (it.array->m_type == RAS_DisplayArray::TRIANGLE)
glBegin(GL_TRIANGLES);
else
glBegin(GL_QUADS);
for (i = 0; i < it.totindex; i += numvert)
{
if (obcolor)
glColor4d(rgba[0], rgba[1], rgba[2], rgba[3]);
for (j = 0; j < numvert; j++) {
vertex = &it.vertex[it.index[i+j]];
if (!wireframe) {
if (!obcolor)
glColor4ubv((const GLubyte *)(vertex->getRGBA()));
glNormal3fv(vertex->getNormal());
if (multi)
TexCoord(*vertex);
else
glTexCoord2fv(vertex->getUV(0));
}
glVertex3fv(vertex->getXYZ());
}
}
glEnd();
}
}
}
