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)); }