ogre实现加入物理效果terrain

最新推荐文章于 2022-04-04 01:21:48 发布
最新推荐文章于 2022-04-04 01:21:48 发布
阅读量1.9k 收藏
点赞数 1
分类专栏： OGRE 文章标签： vector descriptor iterator delete blend actor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/pizi0475/article/details/5345996
版权

view plaincopy to clipboardprint?
//------------------------------------------------------------------------------------------------  
void TriangleMeshData::addVertexData(const VertexData *vertex_data,  
                                   const VertexData *blended_data,  
                                   const Mesh::IndexMap *indexMap)  
{  
    if (!vertex_data)   
        return;  
 
    const VertexData *data = (blended_data) ? blended_data: vertex_data;  
 
    const unsigned int prev_size = _vertex_count;  
    _vertex_count += (unsigned int)data->vertexCount;  
 
    Ogre::Vector3* tmp_vert = new Ogre::Vector3[_vertex_count];  
    if (_vertices)  
    {  
        memcpy(tmp_vert,_vertices,sizeof(Vector3) * prev_size);  
        delete[] _vertices;  
    }  
    _vertices = tmp_vert;  
 
    // Get the positional buffer element  
    {     
        const Ogre::VertexElement* posElem = data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);            
        Ogre::HardwareVertexBufferSharedPtr vbuf = data->vertexBufferBinding->getBuffer(posElem->getSource());  
        const unsigned int vSize = (unsigned int)vbuf->getVertexSize();  
 
        unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));  
        float* pReal;  
        Ogre::Vector3 * curVertices = &_vertices[prev_size];  
        const unsigned int vertexCount = (unsigned int)data->vertexCount;  
        for(unsigned int j = 0; j < vertexCount; ++j)  
        {  
            posElem->baseVertexPointerToElement(vertex, &pReal);  
            vertex += vSize;  
 
            curVertices->x = (*pReal++);  
            curVertices->y = (*pReal++);  
            curVertices->z = (*pReal++);  
 
//            *curVertices = _transform * (*curVertices);  
 
            curVertices++;  
        }  
        vbuf->unlock();  
    }  
 
    // Get the bone index element  
    if (_entity && _entity->hasSkeleton())  
    {  
 
        Ogre::MeshPtr mesh = _entity->getMesh ();  
 
        const Ogre::VertexElement* bneElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_BLEND_INDICES);  
        assert (bneElem);  
        {  
            Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(bneElem->getSource());  
            const unsigned int vSize = (unsigned int)vbuf->getVertexSize();  
            unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));  
 
            unsigned char* pBone;  
 
            if (!_bone_mapping)  
                _bone_mapping = new BoneMapping();    
            BoneMapping::iterator i;  
 
            Ogre::Vector3 * curVertices = &_vertices[prev_size];  
 
            const unsigned int vertexCount = (unsigned int)vertex_data->vertexCount;  
            for(unsigned int j = 0; j < vertexCount; ++j)  
            {  
                bneElem->baseVertexPointerToElement(vertex, &pBone);  
                vertex += vSize;  
 
                const unsigned char currBone = (indexMap) ? (*indexMap)[*pBone] : *pBone;  
                i = _bone_mapping->find (currBone);  
                Vector3Array* l = 0;  
                if (i == _bone_mapping->end())  
                {  
                    l = new Vector3Array;  
                    _bone_mapping->insert(BoneMappingKey(currBone, l));  
                }                         
                else   
                {  
                    l = i->second;  
                }  
 
                l->push_back(*curVertices);  
 
                curVertices++;  
            }  
            vbuf->unlock();  
        }  
    }  
} 
//------------------------------------------------------------------------------------------------
void TriangleMeshData::addVertexData(const VertexData *vertex_data,
                                   const VertexData *blended_data,
                                   const Mesh::IndexMap *indexMap)
{
    if (!vertex_data)
        return;

    const VertexData *data = (blended_data) ? blended_data: vertex_data;

    const unsigned int prev_size = _vertex_count;
    _vertex_count += (unsigned int)data->vertexCount;

    Ogre::Vector3* tmp_vert = new Ogre::Vector3[_vertex_count];
    if (_vertices)
    {
        memcpy(tmp_vert,_vertices,sizeof(Vector3) * prev_size);
        delete[] _vertices;
    }
    _vertices = tmp_vert;

    // Get the positional buffer element
    { 
        const Ogre::VertexElement* posElem = data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);   
        Ogre::HardwareVertexBufferSharedPtr vbuf = data->vertexBufferBinding->getBuffer(posElem->getSource());
        const unsigned int vSize = (unsigned int)vbuf->getVertexSize();

        unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
        float* pReal;
        Ogre::Vector3 * curVertices = &_vertices[prev_size];
        const unsigned int vertexCount = (unsigned int)data->vertexCount;
        for(unsigned int j = 0; j < vertexCount; ++j)
        {
            posElem->baseVertexPointerToElement(vertex, &pReal);
            vertex += vSize;

            curVertices->x = (*pReal++);
            curVertices->y = (*pReal++);
            curVertices->z = (*pReal++);

//            *curVertices = _transform * (*curVertices);

            curVertices++;
        }
        vbuf->unlock();
    }

    // Get the bone index element
    if (_entity && _entity->hasSkeleton())
    {

        Ogre::MeshPtr mesh = _entity->getMesh ();

        const Ogre::VertexElement* bneElem = vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_BLEND_INDICES);
        assert (bneElem);
        {
            Ogre::HardwareVertexBufferSharedPtr vbuf = vertex_data->vertexBufferBinding->getBuffer(bneElem->getSource());
            const unsigned int vSize = (unsigned int)vbuf->getVertexSize();
            unsigned char* vertex = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));

            unsigned char* pBone;

            if (!_bone_mapping)
                _bone_mapping = new BoneMapping(); 
            BoneMapping::iterator i;

            Ogre::Vector3 * curVertices = &_vertices[prev_size];

            const unsigned int vertexCount = (unsigned int)vertex_data->vertexCount;
            for(unsigned int j = 0; j < vertexCount; ++j)
            {
                bneElem->baseVertexPointerToElement(vertex, &pBone);
                vertex += vSize;

                const unsigned char currBone = (indexMap) ? (*indexMap)[*pBone] : *pBone;
                i = _bone_mapping->find (currBone);
                Vector3Array* l = 0;
                if (i == _bone_mapping->end())
                {
                    l = new Vector3Array;
                    _bone_mapping->insert(BoneMappingKey(currBone, l));
                }      
                else
                {
                    l = i->second;
                }

                l->push_back(*curVertices);

                curVertices++;
            }
            vbuf->unlock();
        }
    }
}
  从ogre中设置terrain的物理效果我认为可以分成两类：

第一类很简单是从高度图直接读出然后建立定点索引序列，自己动手创建地形；

第二类是从实体创建，很简单的说就是从mesh模型来创建，这样的好处就是不用自己渲染了。。。

现在只实现了第二类的方法，其实本质就是从mesh里提取顶点信息和索引信息然后填充到

    NxTriangleMeshDesc* triangleMeshDesc; 剩下的无非是生成对应的模型而已；

 view plaincopy to clipboardprint?
NxActor* PhysxTool::CreateTriangleMesh(TriangleMeshData* data,NxPhysicsSDK *gPhysicsSDK,NxScene*gScene)  
    
{  
    NxTriangleMeshDesc* triangleMeshDesc;  
    // Create descriptor for triangle mesh  
    triangleMeshDesc= new NxTriangleMeshDesc();  
    triangleMeshDesc->numVertices            = data->getVertexCount();  
    triangleMeshDesc->pointStrideBytes       = sizeof(NxVec3);  
    triangleMeshDesc->points             = (void*)data->getVertices();  
    triangleMeshDesc->numTriangles           = data->getIndexCount()/3;  
    triangleMeshDesc->flags                  = 0;  
    triangleMeshDesc->triangles              = (void*)data->getIndices();  
    triangleMeshDesc->triangleStrideBytes    = 3 * sizeof(NxU32);  
 
    triangleMeshDesc->heightFieldVerticalAxis= NX_Y;     
    triangleMeshDesc->heightFieldVerticalExtent= -1000.0f;  
 
    // The actor has one shape, a triangle mesh  
    NxInitCooking();  
    MemoryWriteBuffer buf;  
 
    bool status = NxCookTriangleMesh(*triangleMeshDesc, buf);  
    NxTriangleMesh* pMesh;  
    if (status)  
    {  
        pMesh = gPhysicsSDK->createTriangleMesh(MemoryReadBuffer(buf.data));  
    }  
    else 
    {  
        assert(false);  
        pMesh = NULL;  
    }  
    NxCloseCooking();  
    // Create TriangleMesh above code segment.  
 
    NxTriangleMeshShapeDesc tmsd;  
    tmsd.meshData       = pMesh;  
    tmsd.userData       = triangleMeshDesc;  
    tmsd.localPose.t    = NxVec3(0, 0, 0);  
    tmsd.meshPagingMode = NX_MESH_PAGING_AUTO;  
    tmsd.shapeFlags     = NX_SF_FEATURE_INDICES;  
    NxActorDesc actorDesc;  
 
    assert(tmsd.isValid());  
    actorDesc.shapes.pushBack(&tmsd);  
    if (pMesh)  
        return gScene->createActor(actorDesc);  
    else 
        return NULL;  
} 
NxActor* PhysxTool::CreateTriangleMesh(TriangleMeshData* data,NxPhysicsSDK *gPhysicsSDK,NxScene*gScene)
 
{
    NxTriangleMeshDesc* triangleMeshDesc;
    // Create descriptor for triangle mesh
    triangleMeshDesc= new NxTriangleMeshDesc();
    triangleMeshDesc->numVertices   = data->getVertexCount();
    triangleMeshDesc->pointStrideBytes  = sizeof(NxVec3);
    triangleMeshDesc->points    = (void*)data->getVertices();
    triangleMeshDesc->numTriangles   = data->getIndexCount()/3;
    triangleMeshDesc->flags     = 0;
    triangleMeshDesc->triangles    = (void*)data->getIndices();
    triangleMeshDesc->triangleStrideBytes = 3 * sizeof(NxU32);

    triangleMeshDesc->heightFieldVerticalAxis= NX_Y;  
    triangleMeshDesc->heightFieldVerticalExtent= -1000.0f;

    // The actor has one shape, a triangle mesh
    NxInitCooking();
    MemoryWriteBuffer buf;

    bool status = NxCookTriangleMesh(*triangleMeshDesc, buf);
    NxTriangleMesh* pMesh;
    if (status)
    {
        pMesh = gPhysicsSDK->createTriangleMesh(MemoryReadBuffer(buf.data));
    }
    else
    {
        assert(false);
        pMesh = NULL;
    }
    NxCloseCooking();
    // Create TriangleMesh above code segment.

    NxTriangleMeshShapeDesc tmsd;
    tmsd.meshData  = pMesh;
    tmsd.userData  = triangleMeshDesc;
    tmsd.localPose.t = NxVec3(0, 0, 0);
    tmsd.meshPagingMode = NX_MESH_PAGING_AUTO;
    tmsd.shapeFlags     = NX_SF_FEATURE_INDICES;
    NxActorDesc actorDesc;

    assert(tmsd.isValid());
    actorDesc.shapes.pushBack(&tmsd);
    if (pMesh)
        return gScene->createActor(actorDesc);
    else
        return NULL;
}
 

返回的actor就可以直接使用了，因为没有设置body，所以默认为static，当有物体落到表面是自动进行碰撞检测；

这个实现的关键还在于对mesh的数据的提取，这是从ogreode中“剽窃”的一段代码，演示如何提取顶点数据和索引数据；

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
//const bool isHWanimated = isSkeletonAnimated && entity->isHardwareAnimationEnabled();  
if (isSkeletonAnimated)  
{  
    _entity->addSoftwareAnimationRequest(false);  
    _entity->_updateAnimation();  
}  
 
 
if (_entity->getMesh()->sharedVertexData)  
{  
    if (!isSkeletonAnimated)  
        addVertexData (_entity->getMesh()->sharedVertexData);  
    else 
        addVertexData (_entity->getMesh()->sharedVertexData,   
        _entity->_getSkelAnimVertexData(),  
        &_entity->getMesh()->sharedBlendIndexToBoneIndexMap);   
}  
 
for(unsigned int i = 0;i < _entity->getNumSubEntities();++i)  
{  
    SubMesh *sub_mesh = _entity->getSubEntity(i)->getSubMesh();  
 
    if (!sub_mesh->useSharedVertices)  
    {  
        addIndexData(sub_mesh->indexData,_vertex_count);  
 
        if (!isSkeletonAnimated)  
            addVertexData (sub_mesh->vertexData);  
        else 
            addVertexData (sub_mesh->vertexData,   
            _entity->getSubEntity(i)->_getSkelAnimVertexData(),  
            &sub_mesh->blendIndexToBoneIndexMap);   
    }  
    else   
    {  
        addIndexData (sub_mesh->indexData);  
    }  
 
} 
    //const bool isHWanimated = isSkeletonAnimated && entity->isHardwareAnimationEnabled();
    if (isSkeletonAnimated)
    {
        _entity->addSoftwareAnimationRequest(false);
        _entity->_updateAnimation();
    }


    if (_entity->getMesh()->sharedVertexData)
    {
        if (!isSkeletonAnimated)
            addVertexData (_entity->getMesh()->sharedVertexData);
        else
            addVertexData (_entity->getMesh()->sharedVertexData,
            _entity->_getSkelAnimVertexData(),
            &_entity->getMesh()->sharedBlendIndexToBoneIndexMap);
    }

    for(unsigned int i = 0;i < _entity->getNumSubEntities();++i)
    {
        SubMesh *sub_mesh = _entity->getSubEntity(i)->getSubMesh();

        if (!sub_mesh->useSharedVertices)
        {
            addIndexData(sub_mesh->indexData,_vertex_count);

            if (!isSkeletonAnimated)
                addVertexData (sub_mesh->vertexData);
            else
                addVertexData (sub_mesh->vertexData,
                _entity->getSubEntity(i)->_getSkelAnimVertexData(),
                &sub_mesh->blendIndexToBoneIndexMap);
        }
        else
        {
            addIndexData (sub_mesh->indexData);
        }

    }

addindex和addvertex分别向该类中写入数据：

view plaincopy to clipboardprint?
void TriangleMeshData::addIndexData(IndexData *data, const unsigned int offset)  
{  
    const unsigned int prev_size = _index_count;  
    _index_count += (unsigned int)data->indexCount;  
 
    TriangleIndex* tmp_ind = new TriangleIndex[_index_count];  
    if (_indices)  
    {  
        memcpy (tmp_ind, _indices, sizeof(unsigned int) * prev_size);  
        delete[] _indices;  
    }  
    _indices = tmp_ind;  
 
    const unsigned int numTris = (unsigned int) data->indexCount / 3;  
    HardwareIndexBufferSharedPtr ibuf = data->indexBuffer;     
    const bool use32bitindexes = (ibuf->getType() == HardwareIndexBuffer::IT_32BIT);  
    unsigned int index_offset = prev_size;  
 
    if (use32bitindexes)   
    {  
        const unsigned int* pInt = static_cast<unsigned int*>(ibuf->lock(HardwareBuffer::HBL_READ_ONLY));  
        for(unsigned int k = 0; k < numTris; ++k)  
        {  
            _indices[index_offset ++] = offset + *pInt++;  
            _indices[index_offset ++] = offset + *pInt++;  
            _indices[index_offset ++] = offset + *pInt++;  
        }  
        ibuf->unlock();  
    }  
    else   
    {  
        const unsigned short* pShort = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_READ_ONLY));  
        for(unsigned int k = 0; k < numTris; ++k)  
        {  
            _indices[index_offset ++] = offset + static_cast<unsigned int> (*pShort++);  
            _indices[index_offset ++] = offset + static_cast<unsigned int> (*pShort++);  
            _indices[index_offset ++] = offset + static_cast<unsigned int> (*pShort++);  
        }  
        ibuf->unlock();  
    }  
 
} 
void TriangleMeshData::addIndexData(IndexData *data, const unsigned int offset)
{
    const unsigned int prev_size = _index_count;
    _index_count += (unsigned int)data->indexCount;

    TriangleIndex* tmp_ind = new TriangleIndex[_index_count];
    if (_indices)
    {
        memcpy (tmp_ind, _indices, sizeof(unsigned int) * prev_size);
        delete[] _indices;
    }
    _indices = tmp_ind;

    const unsigned int numTris = (unsigned int) data->indexCount / 3;
    HardwareIndexBufferSharedPtr ibuf = data->indexBuffer; 
    const bool use32bitindexes = (ibuf->getType() == HardwareIndexBuffer::IT_32BIT);
    unsigned int index_offset = prev_size;

    if (use32bitindexes)
    {
        const unsigned int* pInt = static_cast<unsigned int*>(ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
        for(unsigned int k = 0; k < numTris; ++k)
        {
            _indices[index_offset ++] = offset + *pInt++;
            _indices[index_offset ++] = offset + *pInt++;
            _indices[index_offset ++] = offset + *pInt++;
        }
        ibuf->unlock();
    }
    else
    {
        const unsigned short* pShort = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
        for(unsigned int k = 0; k < numTris; ++k)
        {
            _indices[index_offset ++] = offset + static_cast<unsigned int> (*pShort++);
            _indices[index_offset ++] = offset + static_cast<unsigned int> (*pShort++);
            _indices[index_offset ++] = offset + static_cast<unsigned int> (*pShort++);
        }
        ibuf->unlock();
    }

}

 

本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/liu3xing3long/archive/2009/01/30/3855286.aspx

OGRE雾化效果入门
熊小屁的专栏
03-13 1861
<br />[编辑] 雾化效果 <br />[编辑] 入门 <br />雾化效果在OGRE里非常简单。但是在你使用它之前要注意，当你使用地面管理器(TerrainSceneManager)的时候，一定要在调用setWorldGeometry函数之前调用setFog函数。(别的场景管理器里没关系的)。根据你调用这两个函数的顺序，不同的顶点程序会被调用。(注意在OGRE 1.0.0 里有一个Bug，当你使用正确顺序调用这些函数的时候，指数雾化不会被渲染。这个Bug在1.0.1的时候就已经被修复了)。 <br /
常见3D游戏物理引擎总结
徐阳的专栏
07-05 9921
1.  Havok: 老牌的君王，支持功能如下：http://www.havok.com ·         Collision Detection - including Continuous Physics™ ·         MOPP™ Technology - for compact representation of large collision meshes ·
OGRE 效果展示
zhucde(虚拟闲人)的专栏
07-26 4792
BSP效果 CubeMap海洋动态的鱼+动态的水面水面效果+涟漪.JPG骨骼动画+真实的影子.JPG碰撞.jpg可更改的影像效果,本图中用其中的一项来示例:HDR粒子.jpg
Ogre相关的物理引擎
痞子龙3D编程
08-13 2478
可用于OGRE的物理引擎有挺多的，很多开发者已经写好了适配器，将两OGRE与其它的物理引擎进行了连接。 比较著名的就是： NxOgre:连接OGRE和physx。 http://www.ogre3d.org/tikiwiki/NxOgre OgreNewt: http://www.ogre3d.org/tikiwiki/OgreNewt http://www.ogre3d.org/ti
在Ogre中使用Havok物理引擎(源码)
痞子龙3D编程
07-14 4139
作者:CYM 众所周知Ogre则是评价很高的一款图形渲染引擎,Havok则是世界一流的物理引擎,今天花了点时间将两者结合在了一块,做了个Demo 由于国内对Havok的研究似乎很少,网上也找不到多少资料,所以先分享一下源码.. 演示了很多棍子掉落在地上的场景   --------------------------------------------华丽分割线----
0009Ogre实现起伏定型，云雾效果
gendlee1991的专栏
10-28 397
起伏地形和天空，雾的实现，公有继承Ogre中的示例类。
Inside ORGE：ogre引擎内核分析，orge内核。orge分析，orge游戏
02-24
OGRE提供了多种SceneManager实现，如OctreeSceneManager、TerrainSceneManager和BspSceneManager，以适应不同的场景需求。 - **Entity与SceneNode**：Entity代表场景中的具体物体，如模型、光源或摄像机。然而，...
剖析虚幻渲染体系（14）- 延展篇：现代渲染引擎演变史Part 1（萌芽期）
www_xuhss_com的博客
04-04 6106
Python微信订餐小程序课程视频 https://edu.youkuaiyun.com/course/detail/36074 Python实战量化交易理财系统 https://edu.youkuaiyun.com/course/detail/35475 目录* 14.1 本篇概述 + 14.1.1 游戏引擎简介 + 14.1.2 游戏引擎模块 + 14.1.3 游戏引擎列表 - 14.1.3.1 Unreal Engine - 14.1.3.2 Unity - 14.1.3.3 CryEngine - 14.1.3.4 Doo
OgreOpcode碰撞检测
09-25
OgreOpcode是Ogre3D图形引擎的一个扩展库，用于实现高效的碰撞检测功能。由于其轻量级的特性，它成为了不使用完整物理引擎时的理想选择。然而，由于文档相对匮乏，初次接触OgreOpcode的开发者可能会遇到不少困难。...
天龙源码框架分析_天龙八部源码描述【转】
weixin_39547596的博客
12-20 5471
天龙八部(武侠世界)的源码很可能是天龙八部代码流出后改写的，因为在看了代码中可以找到一些证据，整个客户端分为：一个是编辑器，一个是客户端，采用OGRE+cegui+自写的简单的物理碰撞检测+FMOD+自写的网络库。服务器端代码目前没仔细关注客户端总体的描述如下：UI系统 CEGUI UI基础系统CEGUI渲染器Expat XML解析器 CEGUI依赖，估计编写者不喜欢用FreeType2 跨平台、...
【Ogre编程入门与进阶】第八章 地形、天空与雾化效果
Everything is possible
01-12 5586
在一款完整的3D游戏或是三维动画中，大地和天空都是构建场景时不可缺少的元素，另外，伴随着游戏中的角色形象上变得越来越饱满，越来越细节化，游戏中的地形系统也随着时间的推移变得越来越真实，越来越复杂，我们可以想象一副具有真实感的地形会给玩家带来多大的震撼效果，因此，在游戏引擎中地形系统的重要性就不言而喻了。         目前，游戏中有很多种方法来制作地形系统，当然，每一种方法都有它的优势和弱项。
Ogre的物理引擎介绍
friddle的专栏
12-08 973
三个主要物理引擎 大大小小n个 主要三个： PhysicX-->Nxogre Bullet---->OgreBullet ODE-->OgreODE ‘Bullet是开源的------ 基本上所有的引擎都试过-- 话说OgreBullet和OgreODE都必须是Ogre老版本，都没有在VS2010下编译成功。尤其是OgreBullet的Demon的需要版本特别老
用Ogre做一个效率高又漂亮的水面
LuoyinanRoy的专栏
07-07 1万+
以前游戏水面的做法都是用很多张图的序列帧实现的纹理动画，这种固定渲染管线的方式，在最低画质的时候采用特别好，但是对于更高级别的画质，就应该采用更好效果的水面。 水面渲染，Ogre有个插件叫Hydrax，效果很不错，但是效率也低的很，没任何实用价值。只好自己做一个。 一个漂亮3D游戏水面的，一般有水波模拟，bump mapping，倒影，折射，菲捏尔效果，水下效果等，我准备做一些取舍，实
Ogre的Physic推荐 物理引擎
friddle的专栏
12-09 923
原帖： http://www.ogre3d.org/forums/viewtopic.php?f=10&t=63839 原文： Yeah, it's hard to point to any one engine as definitely the best, since they are all quite different. They have different co
view plaincopy to clipboardprint?
ShanDong_Chu
08-23 2731
//方法1   protected void Page_Load(object sender, EventArgs e)       {           if (!Page.IsPostBack)           {               ReplaceStr();           }       }       public void ReplaceStr()       { 
JAVA class反编译还原
weixin_30767835的博客
06-23 173
class反编译还原 java class 利用jad 反编译之后，偶尔回碰到一些不正常的代码，例如：label0 :_L1 MISSING_BLOCK_LABEL_30、JVM INSTR ret 7 、JVM INSTR tableswitch 1 3: default 269、 JVM INSTR monitorexit、JVM INSTR monitorenter，这些一般是由特殊的fo...
使用C#播放MP3/WAV文件的四种方式
热门推荐
神隐的博客
09-26 3万+
第一种：使用C#自带的SoundPlayer view plaincopy to clipboardprint? using System.Media;       SoundPlayer sound = new SoundPlayer("声音.wav");   sound.Play();   using System.Media; SoundPlayer sound
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值