void TextField::render(int x, int y)
{
glPushMatrix();
glTranslatef((float)x, (float)y, 0);
glBindTexture(GL_TEXTURE_2D, getTextureId());
glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
glTexCoord2f(0, 0); glVertex2i(1, 1);
glTexCoord2f(1, 0); glVertex2i(m_texture_width + 1, 1);
glTexCoord2f(1, 1); glVertex2i(m_texture_width + 1, m_texture_height + 1);
glTexCoord2f(0, 1); glVertex2i(1, m_texture_height + 1);
glColor3ub((m_colour >> 16) & 0xFF, (m_colour >> 8) & 0xFF, m_colour & 0xFF);
glTexCoord2f(0, 0); glVertex2i(0, 0);
glTexCoord2f(1, 0); glVertex2i(m_texture_width, 0);
glTexCoord2f(1, 1); glVertex2i(m_texture_width, m_texture_height);
glTexCoord2f(0, 1); glVertex2i(0, m_texture_height);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glPopMatrix();
}
bool RenderTextureOpenGL::create(const Vector2& size, RenderTextureFormat format, int depth)
{
if (!createRenderbuffer(size, depth))
return false;
if (!createTexture(size, format))
return false;
glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, getTextureId(), 0);
if (mDepth > 0)
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, mDepthBuffer);
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(status != GL_FRAMEBUFFER_COMPLETE)
{
//TODO: Error log;
return false;
}
mSize = size;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return true;
}
video::ITexture* TextureSource::getTexture(const std::string &name, u32 *id)
{
u32 actual_id = getTextureId(name);
if(id){
*id = actual_id;
}
return getTexture(actual_id);
}
// __________________________________________________________________________________________________
void KikiBillBoard::display()
{
glPushMatrix();
getColor().glColor();
current_position.glTranslate();
displayTextureWithSize (getTextureId(), size);
glPopMatrix();
}
void Block::Draw(long posX, long posY, App &app, TextureContainer &tC, unsigned short metadata)
{
sf::Sprite *&&tempSprite = &(tC.getTextures(getTextureName())[getTextureId(app, metadata)]);
if (tempSprite != nullptr)
{
tempSprite->setPosition(posX, posY);
app.draw(*tempSprite);
}
}
void ChunkBase::writeTextureCoords(const CubeFace* face, float* buffer)
{
uint32_t textureId = getTextureId(face);
uint8_t uIndex = textureId & 0x0F;
uint8_t vIndex = (textureId & 0xF0) >> 4;
buffer[0] = (float) (uIndex / 16.0);
buffer[1] = (float) (vIndex / 16.0);
}
bool RenderTextureOpenGL::createTexture(const Vector2& size, RenderTextureFormat format)
{
GLenum target = getTarget();
glBindTexture(target, getTextureId());
glTexImage2D(target, 0, RENDER_TEXTURE_FORMAT_MAP[format], (GLsizei)size.x, (GLsizei)size.y, 0,
RENDER_TEXTURE_NRMFMT_MAP[format], GL_FLOAT, 0);
glBindTexture(target, 0);
setFilterMode(FM_POINT);
setWrapMode(TWM_CLAMP);
return true;
}
void GLDisplay::advanceTime(void)
{
static int holdon = 1;
// check if image has changed
//
if (image != NULL && lastUpdateTime < image->lastUpdate() && holdon) {
holdon = 1;
loadTexture(getTextureId(image), image);
lastUpdateTime = time;
}
int status = parent->advanceTime(time);
if (status == PV_SUCCESS || status == PV_EXIT_NORMALLY) {
time = parent->simulationTime();
}
else {
fprintf(stderr,"GLDisplay::advanceTime returned abnormal status %d\n",status);
abort();
}
}
TextureFrame* TextureCache::getSpriteFrame(const std::string& key)
{
auto frame = _frames.get(key);
if (!frame)
{
return frame;
}
if (frame->getTexture())
{
return frame;
}
auto texture = getTexture2d(frame->getTextureId());
if (texture)
{
frame->setTexture(texture);
return frame;
}
return nullptr;
}
// Mesh bin export
bool exportMeshBin(const char * filename, MMesh * mesh)
{
int version = 2;
char rep[256];
bool state;
// create file
MFile * file = M_fopen(filename, "wb");
if(! file)
{
printf("Error : can't create file %s\n", filename);
return false;
}
// get file directory
getRepertory(rep, filename);
// header
M_fwrite(M_MESH_HEADER, sizeof(char), 8, file);
// version
M_fwrite(&version, sizeof(int), 1, file);
// Animation
{
// anim refs
MArmatureAnimRef * armatureAnimRef = mesh->getArmatureAnimRef();
MTexturesAnimRef * texturesAnimRef = mesh->getTexturesAnimRef();
MMaterialsAnimRef * materialsAnimRef = mesh->getMaterialsAnimRef();
// armature anim ref
writeDataRef(file, armatureAnimRef, rep);
// textures anim ref
writeDataRef(file, texturesAnimRef, rep);
// materials anim ref
writeDataRef(file, materialsAnimRef, rep);
// anims ranges
unsigned int animsRangesNumber = mesh->getAnimsRangesNumber();
MAnimRange * animsRanges = mesh->getAnimsRanges();
M_fwrite(&animsRangesNumber, sizeof(int), 1, file);
if(animsRangesNumber > 0)
M_fwrite(animsRanges, sizeof(MAnimRange), animsRangesNumber, file);
}
// Textures
{
unsigned int t, texturesNumber = mesh->getTexturesNumber();
M_fwrite(&texturesNumber, sizeof(int), 1, file);
for(t=0; t<texturesNumber; t++)
{
MTexture * texture = mesh->getTexture(t);
MTextureRef * textureRef = texture->getTextureRef();
M_TEX_GEN_MODES genMode = texture->getGenMode();
M_WRAP_MODES UWrapMode = texture->getUWrapMode();
M_WRAP_MODES VWrapMode = texture->getVWrapMode();
MVector2 texTranslate = texture->getTexTranslate();
MVector2 texScale = texture->getTexScale();
float texRotate = texture->getTexRotate();
// texture ref
writeDataRef(file, textureRef, rep);
if(textureRef)
{
bool mipmap = textureRef->isMipmapEnabled();
M_fwrite(&mipmap, sizeof(bool), 1, file);
}
// data
M_fwrite(&genMode, sizeof(M_TEX_GEN_MODES), 1, file);
M_fwrite(&UWrapMode, sizeof(M_WRAP_MODES), 1, file);
M_fwrite(&VWrapMode, sizeof(M_WRAP_MODES), 1, file);
M_fwrite(&texTranslate, sizeof(MVector2), 1, file);
M_fwrite(&texScale, sizeof(MVector2), 1, file);
M_fwrite(&texRotate, sizeof(float), 1, file);
}
}
// Materials
{
unsigned int m, materialsNumber = mesh->getMaterialsNumber();
M_fwrite(&materialsNumber, sizeof(int), 1, file);
for(m=0; m<materialsNumber; m++)
{
MMaterial * material = mesh->getMaterial(m);
int type = material->getType();
float opacity = material->getOpacity();
float shininess = material->getShininess();
float customValue = material->getCustomValue();
M_BLENDING_MODES blendMode = material->getBlendMode();
MVector3 emit = material->getEmit();
MVector3 diffuse = material->getDiffuse();
MVector3 specular = material->getSpecular();
MVector3 customColor = material->getCustomColor();
MFXRef * FXRef = material->getFXRef();
MFXRef * ZFXRef = material->getZFXRef();
// FX ref
state = FXRef != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(FXRef)
{
MShaderRef * vertShadRef = FXRef->getVertexShaderRef();
MShaderRef * pixShadRef = FXRef->getPixelShaderRef();
writeDataRef(file, vertShadRef, rep);
writeDataRef(file, pixShadRef, rep);
}
// Z FX ref
state = ZFXRef != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(ZFXRef)
{
MShaderRef * vertShadRef = ZFXRef->getVertexShaderRef();
MShaderRef * pixShadRef = ZFXRef->getPixelShaderRef();
writeDataRef(file, vertShadRef, rep);
writeDataRef(file, pixShadRef, rep);
}
// data
M_fwrite(&type, sizeof(int), 1, file);
M_fwrite(&opacity, sizeof(float), 1, file);
M_fwrite(&shininess, sizeof(float), 1, file);
M_fwrite(&customValue, sizeof(float), 1, file);
M_fwrite(&blendMode, sizeof(M_BLENDING_MODES), 1, file);
M_fwrite(&emit, sizeof(MVector3), 1, file);
M_fwrite(&diffuse, sizeof(MVector3), 1, file);
M_fwrite(&specular, sizeof(MVector3), 1, file);
M_fwrite(&customColor, sizeof(MVector3), 1, file);
// textures pass
unsigned int t, texturesPassNumber = material->getTexturesPassNumber();
M_fwrite(&texturesPassNumber, sizeof(int), 1, file);
for(t=0; t<texturesPassNumber; t++)
{
MTexturePass * texturePass = material->getTexturePass(t);
MTexture * texture = texturePass->getTexture();
unsigned int mapChannel = texturePass->getMapChannel();
M_TEX_COMBINE_MODES combineMode = texturePass->getCombineMode();
// texture id
int textureId = getTextureId(mesh, texture);
M_fwrite(&textureId, sizeof(int), 1, file);
// data
M_fwrite(&mapChannel, sizeof(int), 1, file);
M_fwrite(&combineMode, sizeof(M_TEX_COMBINE_MODES), 1, file);
}
}
}
// Bones
{
MArmature * armature = mesh->getArmature();
state = armature != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(armature)
{
unsigned int b, bonesNumber = armature->getBonesNumber();
M_fwrite(&bonesNumber, sizeof(int), 1, file);
for(b=0; b<bonesNumber; b++)
{
MOBone * bone = armature->getBone(b);
MObject3d * parent = bone->getParent();
MVector3 position = bone->getPosition();
MVector3 scale = bone->getScale();
MQuaternion rotation = bone->getRotation();
// name
writeString(file, bone->getName());
// parent id
int parentId = -1;
if(parent)
{
unsigned int id;
if(armature->getBoneId(parent->getName(), &id))
parentId = (int)id;
}
M_fwrite(&parentId, sizeof(int), 1, file);
// position / rotation / scale
M_fwrite(&position, sizeof(MVector3), 1, file);
M_fwrite(&rotation, sizeof(MQuaternion), 1, file);
M_fwrite(&scale, sizeof(MVector3), 1, file);
}
}
}
// BoundingBox
{
MBox3d * box = mesh->getBoundingBox();
M_fwrite(box, sizeof(MBox3d), 1, file);
}
// SubMeshs
{
unsigned int s, subMeshsNumber = mesh->getSubMeshsNumber();
MSubMesh * subMeshs = mesh->getSubMeshs();
M_fwrite(&subMeshsNumber, sizeof(int), 1, file);
for(s=0; s<subMeshsNumber; s++)
{
MSubMesh * subMesh = &(subMeshs[s]);
unsigned int indicesSize = subMesh->getIndicesSize();
unsigned int verticesSize = subMesh->getVerticesSize();
unsigned int normalsSize = subMesh->getNormalsSize();
unsigned int tangentsSize = subMesh->getTangentsSize();
unsigned int texCoordsSize = subMesh->getTexCoordsSize();
unsigned int colorsSize = subMesh->getColorsSize();
M_TYPES indicesType = subMesh->getIndicesType();
void * indices = subMesh->getIndices();
MColor * colors = subMesh->getColors();
MVector3 * vertices = subMesh->getVertices();
MVector3 * normals = subMesh->getNormals();
MVector3 * tangents = subMesh->getTangents();
MVector2 * texCoords = subMesh->getTexCoords();
MBox3d * box = subMesh->getBoundingBox();
MSkinData * skin = subMesh->getSkinData();
map<unsigned int, unsigned int> * mapChannelOffsets = subMesh->getMapChannelOffsets();
// BoundingBox
M_fwrite(box, sizeof(MBox3d), 1, file);
// indices
M_fwrite(&indicesSize, sizeof(int), 1, file);
if(indicesSize > 0)
{
// indice type
M_fwrite(&indicesType, sizeof(M_TYPES), 1, file);
switch(indicesType)
{
case M_USHORT:
M_fwrite(indices, sizeof(short), indicesSize, file);
break;
case M_UINT:
M_fwrite(indices, sizeof(int), indicesSize, file);
break;
}
}
// vertices
M_fwrite(&verticesSize, sizeof(int), 1, file);
if(verticesSize > 0)
M_fwrite(vertices, sizeof(MVector3), verticesSize, file);
// normals
M_fwrite(&normalsSize, sizeof(int), 1, file);
if(normalsSize > 0)
M_fwrite(normals, sizeof(MVector3), normalsSize, file);
// tangents
M_fwrite(&tangentsSize, sizeof(int), 1, file);
if(tangentsSize > 0)
M_fwrite(tangents, sizeof(MVector3), tangentsSize, file);
// texCoords
M_fwrite(&texCoordsSize, sizeof(int), 1, file);
if(texCoordsSize > 0)
M_fwrite(texCoords, sizeof(MVector2), texCoordsSize, file);
// colors
M_fwrite(&colorsSize, sizeof(int), 1, file);
if(colorsSize > 0)
M_fwrite(colors, sizeof(MColor), colorsSize, file);
// mapChannels
{
unsigned int size = mapChannelOffsets->size();
M_fwrite(&size, sizeof(int), 1, file);
map<unsigned int, unsigned int>::iterator
mit (mapChannelOffsets->begin()),
mend(mapChannelOffsets->end());
for(;mit!=mend;++mit)
{
M_fwrite(&mit->first, sizeof(int), 1, file);
M_fwrite(&mit->second, sizeof(int), 1, file);
}
}
// Skins
state = skin != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(skin)
{
// skin point
unsigned int p, pointsNumber = skin->getPointsNumber();
M_fwrite(&pointsNumber, sizeof(int), 1, file);
for(p=0; p<pointsNumber; p++)
{
MSkinPoint * skinPoint = skin->getPoint(p);
unsigned int vertexId = skinPoint->getVertexId();
unsigned int bonesNumber = skinPoint->getBonesNumber();
unsigned short * bonesIds = skinPoint->getBonesIds();
float * bonesWeights = skinPoint->getBonesWeights();
// data
M_fwrite(&vertexId, sizeof(int), 1, file);
M_fwrite(&bonesNumber, sizeof(int), 1, file);
if(bonesNumber > 0)
{
M_fwrite(bonesIds, sizeof(short), bonesNumber, file);
M_fwrite(bonesWeights, sizeof(float), bonesNumber, file);
}
}
}
// Displays
unsigned int d, displaysNumber = subMesh->getDisplaysNumber();
M_fwrite(&displaysNumber, sizeof(int), 1, file);
for(d=0; d<displaysNumber; d++)
{
MDisplay * display = subMesh->getDisplay(d);
M_PRIMITIVE_TYPES primitiveType = display->getPrimitiveType();
unsigned int begin = display->getBegin();
unsigned int size = display->getSize();
MMaterial * material = display->getMaterial();
M_CULL_MODES cullMode = display->getCullMode();
int materialId = getMaterialId(mesh, material);
// data
M_fwrite(&primitiveType, sizeof(M_PRIMITIVE_TYPES), 1, file);
M_fwrite(&begin, sizeof(int), 1, file);
M_fwrite(&size, sizeof(int), 1, file);
M_fwrite(&materialId, sizeof(int), 1, file);
M_fwrite(&cullMode, sizeof(M_CULL_MODES), 1, file);
}
}
}
M_fclose(file);
return true;
}
/**
* Uniform変数のバインド.
* @param obj レンダーオブジェクト
*/
void BaseBuffer::bindUniforms(const RenderObject* obj) const
{
const unsigned int prg = getProgram();
const VX::Math::matrix& mat = obj->GetTransformMatrix();
SetUniformMatrix_GS[m_mode](prg, "lsgl_World", &mat.f[0]);
// For a convenience, we add inverse and inverse transpose of world matrix to uniform shader variable.
{
VX::Math::matrix invmat = Inverse(mat);
SetUniformMatrix_GS[m_mode](prg, "lsgl_WorldInverse", &invmat.f[0]);
}
{
VX::Math::matrix ivtmat = Transpose(Inverse(mat));
SetUniformMatrix_GS[m_mode](prg, "lsgl_WorldInverseTranspose", &ivtmat.f[0]);
}
const RenderObject::Vec4Map& vec4array = obj->GetUniformVec4();
RenderObject::Vec4Map::const_iterator it4, eit4 = vec4array.end();
for (it4 = vec4array.begin(); it4 != eit4; ++it4) {
const VX::Math::vec4& v4 = it4->second;
SetUniform4fv_GS[m_mode](prg, it4->first.c_str(), (const float*)&v4);
}
const RenderObject::Vec3Map& vec3array = obj->GetUniformVec3();
RenderObject::Vec3Map::const_iterator it3, eit3 = vec3array.end();
for (it3 = vec3array.begin(); it3 != eit3; ++it3) {
const VX::Math::vec4& v3 = it3->second;
SetUniform3fv_GS[m_mode](prg, it3->first.c_str(), (const float*)&v3);
}
const RenderObject::Vec2Map& vec2array = obj->GetUniformVec2();
RenderObject::Vec2Map::const_iterator it2, eit2 = vec2array.end();
for (it2 = vec2array.begin(); it2 != eit2; ++it2) {
const VX::Math::vec4& v2 = it2->second;
SetUniform2fv_GS[m_mode](prg, it2->first.c_str(), (const float*)&v2);
}
const RenderObject::FloatMap& floatarray = obj->GetUniformFloat();
RenderObject::FloatMap::const_iterator itf, eitf = floatarray.end();
for (itf = floatarray.begin(); itf != eitf; ++itf) {
const float vf = itf->second;
SetUniform1f_GS[m_mode](prg, itf->first.c_str(), vf);
}
const RenderObject::IntMap& intarray = obj->GetUniformInt();
RenderObject::IntMap::const_iterator iti, eiti = intarray.end();
for (iti = intarray.begin(); iti != eiti; ++iti) {
const float vi = iti->second;
SetUniform1i_GS[m_mode](prg, iti->first.c_str(), vi);
}
int textureCount = 1; // start from 1. 0 is default texture. Ex: volume texture.
const RenderObject::TextureMap& texarray = obj->GetUniformTexture();
RenderObject::TextureMap::const_iterator itt, eitt = texarray.end();
for (itt = texarray.begin(); itt != eitt; ++itt) {
const BufferImageData* vt = itt->second;
const int texid = getTextureId(vt);
if (texid > 0) {
ActiveTexture_GS[m_mode](textureCount);
BindTexture2D_GS[m_mode](texid);
SetUniform1i_GS[m_mode](prg, itt->first.c_str(), textureCount);
++textureCount;
ActiveTexture_GS[m_mode](0);
}
}
}
// implement LayerProbe interface
//
int GLDisplay::outputState(double timef)
{
return loadTexture(getTextureId(getTargetLayer()), getTargetLayer());
}
osg::ref_ptr<osg::Node> MeshManager::get(size_t idx)
{
/* Not sure if this cache is a good idea since it shares the whole model
* tree. OSG can parent the same sub-tree to multiple points, which should
* be okay as long as the individual sub-trees don't need changing.
*/
auto iter = mModelCache.find(idx);
if(iter != mModelCache.end())
{
osg::ref_ptr<osg::Node> node;
if(iter->second.lock(node))
return node;
}
if(!mModelProgram)
{
mModelProgram = new osg::Program();
mModelProgram->addShader(osgDB::readShaderFile(osg::Shader::VERTEX, "shaders/object.vert"));
mModelProgram->addShader(osgDB::readShaderFile(osg::Shader::FRAGMENT, "shaders/object.frag"));
}
DFOSG::Mesh *mesh = DFOSG::MeshLoader::get().load(idx);
osg::ref_ptr<osg::Geode> geode(new osg::Geode());
for(auto iter = mesh->getPlanes().begin();iter != mesh->getPlanes().end();)
{
osg::ref_ptr<osg::Vec3Array> vtxs(new osg::Vec3Array());
osg::ref_ptr<osg::Vec3Array> nrms(new osg::Vec3Array());
osg::ref_ptr<osg::Vec3Array> binrms(new osg::Vec3Array());
osg::ref_ptr<osg::Vec2Array> texcrds(new osg::Vec2Array());
osg::ref_ptr<osg::Vec4ubArray> colors(new osg::Vec4ubArray());
osg::ref_ptr<osg::DrawElementsUShort> idxs(new osg::DrawElementsUShort(osg::PrimitiveSet::TRIANGLES));
uint16_t texid = iter->getTextureId();
osg::ref_ptr<osg::Texture> tex = TextureManager::get().getTexture(texid);
float width = tex->getTextureWidth();
float height = tex->getTextureHeight();
do {
const std::vector<DFOSG::MdlPlanePoint> &pts = iter->getPoints();
size_t last_total = vtxs->size();
vtxs->resize(last_total + pts.size());
nrms->resize(last_total + pts.size());
binrms->resize(last_total + pts.size());
texcrds->resize(last_total + pts.size());
colors->resize(last_total + pts.size());
idxs->resize((last_total + pts.size() - 2) * 3);
size_t j = last_total;
for(const DFOSG::MdlPlanePoint &pt : pts)
{
uint32_t vidx = pt.getIndex();
(*vtxs)[j].x() = mesh->getPoints()[vidx].x() / 256.0f;
(*vtxs)[j].y() = mesh->getPoints()[vidx].y() / 256.0f;
(*vtxs)[j].z() = mesh->getPoints()[vidx].z() / 256.0f;
(*nrms)[j].x() = iter->getNormal().x() / 256.0f;
(*nrms)[j].y() = iter->getNormal().y() / 256.0f;
(*nrms)[j].z() = iter->getNormal().z() / 256.0f;
(*binrms)[j].x() = iter->getBinormal().x() / 256.0f;
(*binrms)[j].y() = iter->getBinormal().y() / 256.0f;
(*binrms)[j].z() = iter->getBinormal().z() / 256.0f;
(*texcrds)[j].x() = pt.u() / width;
(*texcrds)[j].y() = pt.v() / height;
(*colors)[j] = osg::Vec4ub(255, 255, 255, 255);
if(j >= last_total+2)
{
(*idxs)[(j-2)*3 + 0] = last_total;
(*idxs)[(j-2)*3 + 1] = j-1;
(*idxs)[(j-2)*3 + 2] = j;
}
++j;
}
} while(++iter != mesh->getPlanes().end() && iter->getTextureId() == texid);
osg::ref_ptr<osg::VertexBufferObject> vbo(new osg::VertexBufferObject());
vtxs->setVertexBufferObject(vbo);
nrms->setVertexBufferObject(vbo);
texcrds->setVertexBufferObject(vbo);
colors->setVertexBufferObject(vbo);
colors->setNormalize(true);
osg::ref_ptr<osg::ElementBufferObject> ebo(new osg::ElementBufferObject());
idxs->setElementBufferObject(ebo);
osg::ref_ptr<osg::Geometry> geometry(new osg::Geometry);
geometry->setVertexArray(vtxs);
geometry->setNormalArray(nrms, osg::Array::BIND_PER_VERTEX);
geometry->setTexCoordArray(1, binrms, osg::Array::BIND_PER_VERTEX);
geometry->setTexCoordArray(0, texcrds, osg::Array::BIND_PER_VERTEX);
geometry->setColorArray(colors, osg::Array::BIND_PER_VERTEX);
geometry->setUseDisplayList(false);
geometry->setUseVertexBufferObjects(true);
geometry->addPrimitiveSet(idxs);
/* Cache the stateset used for this texture, so it can be reused for
* multiple models (should help OSG batch together objects with similar
* state).
*/
auto &stateiter = mStateSetCache[texid];
osg::ref_ptr<osg::StateSet> ss;
if(stateiter.lock(ss) && ss)
geometry->setStateSet(ss);
else
{
ss = geometry->getOrCreateStateSet();
ss->setAttributeAndModes(mModelProgram);
ss->addUniform(new osg::Uniform("diffuseTex", 0));
ss->setTextureAttribute(0, tex);
stateiter = ss;
}
geode->addDrawable(geometry);
}
mModelCache[idx] = osg::ref_ptr<osg::Node>(geode);
return geode;
}
AtlasPointer getTexture(const std::string &name)
{
return getTexture(getTextureId(name));
}
