void DrawLightmapPage( int lightmapPageID ) { // assumes that we are already in ortho mode. int lightmapPageWidth, lightmapPageHeight; IMesh* pMesh = materialSystemInterface->GetDynamicMesh( true, NULL, NULL, g_materialDebugLightmap ); // materialSystemInterface->Bind( g_materialWireframe ); // IMesh* pMesh = materialSystemInterface->GetDynamicMesh( g_materialWireframe ); materialSystemInterface->GetLightmapPageSize( lightmapPageID, &lightmapPageWidth, &lightmapPageHeight ); materialSystemInterface->BindLightmapPage( lightmapPageID ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); // texcoord 1 is lightmaptexcoord for fixed function. meshBuilder.TexCoord2f( 1, 0.0f, 0.0f ); meshBuilder.Position3f( 0.0f, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.TexCoord2f( 1, 1.0f, 0.0f ); meshBuilder.Position3f( lightmapPageWidth, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.TexCoord2f( 1, 1.0f, 1.0f ); meshBuilder.Position3f( lightmapPageWidth, lightmapPageHeight, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.TexCoord2f( 1, 0.0f, 1.0f ); meshBuilder.Position3f( 0.0f, lightmapPageHeight, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
void CHoloShipComm::Draw( IMatRenderContext *pRenderContext ) { m_vecPanelWorldOffset.x = -m_flWidth * m_flScale; BaseClass::Draw( pRenderContext ); GetColorVar()->SetVecValue( HOLO_COLOR_HIGHLIGHT ); SetHoloAlpha( 1.0f ); const float flTriangleStart = -0.5f; const float flTriangleHeight = 0.03f; IMesh *pMesh = pRenderContext->GetDynamicMesh( true, 0, 0, GetMaterial() ); CreateSlantedRect( pMesh, 0, flTriangleStart, m_flWidth * -m_flScale, flTriangleHeight ); //CMeshBuilder builder; //builder.Begin( pMesh, MATERIAL_TRIANGLES, 1 ); //builder.Position3f( 0, 0, flTriangleStart ); //builder.AdvanceVertex(); //builder.Position3f( 0, 0, flTriangleStart + flTriangleHeight ); //builder.AdvanceVertex(); //builder.Position3f( 0, -m_flWidth * m_flScale, flTriangleStart ); //builder.AdvanceVertex(); //builder.End(); pMesh->Draw(); if ( m_flWaveVisibilityAmount > 0.0f ) { DrawWaveForm( pRenderContext ); } }
void CReplayRenderer::DrawResolvingQuad( int nWidth, int nHeight ) { CMatRenderContextPtr pRenderContext( g_pMaterialSystem ); IMesh *pMesh = pRenderContext->GetDynamicMesh(); CMeshBuilder meshBuilder; // Epsilons for 1:1 texel to pixel mapping float fWidthEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nWidth); float fHeightEpsilon = IsOSX() ? 0.0f : 0.5f / ((float) nHeight); meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); meshBuilder.Position3f( -1.0f, 1.0f, 0.5f ); // Upper left meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 0.0f + fHeightEpsilon ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( -1.0f, -1.0f, 0.5f ); // Lower left meshBuilder.TexCoord2f( 0, 0.0f + fWidthEpsilon, 1.0f + fHeightEpsilon ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( 1.0f, -1.0f, 0.5f ); // Lower right meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 1.0f + fHeightEpsilon ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( 1.0f, 1.0f, 0.5f ); // Upper right meshBuilder.TexCoord2f( 0, 1.0f + fWidthEpsilon, 0.0f + fHeightEpsilon ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
float CGWIC_Cell::GetTerrainHeightUnderPointMetric(irr::core::vector3df pnt) { u32 x = floor(pnt.X); u32 z = floor(pnt.Z); if (x > 255) x = 255; if (z > 255) z = 255; u32 index = x * 256 + z; IMesh* pMesh = terrain->getMesh(); float res = 0.f; // float max = 0; const float scy = terrain->getScale().Y; //FIXME: get the true position in meters for (u32 n=0; n<pMesh->getMeshBufferCount(); n++) { IMeshBuffer* pMeshBuffer = pMesh->getMeshBuffer(n); if (pMeshBuffer->getVertexType() != EVT_2TCOORDS) continue; S3DVertex2TCoords* pVertices = (S3DVertex2TCoords*)pMeshBuffer->getVertices(); res = pVertices[index].Pos.Y / scy; // res = (pVertices[index].Pos.Y + terrain->getPosition().Y) / scy; // res += terrain->getPosition().Y / GWIC_IRRUNITS_PER_METER; // std::cerr << "POSIT " << res << std::endl; // for (u32 k=0; k<(256*256); k++) if (pVertices[k].Pos.Y > max) max = pVertices[k].Pos.Y; // std::cerr << "MAXX " << max << std::endl; break; } return res; }
//----------------------------------------------------------------------------- // paint it! //----------------------------------------------------------------------------- void CMaterialViewPanel::Paint() { // Draw a background (translucent objects will appear that way) // FIXME: Draw the outline of this panel? if (!m_pMaterial) return; g_pMatSystemSurface->Begin3DPaint( 0, 0, m_iViewableWidth, m_iViewableHeight ); g_pMaterialSystem->MatrixMode( MATERIAL_PROJECTION ); g_pMaterialSystem->LoadIdentity(); g_pMaterialSystem->Scale( 1, -1, 1 ); g_pMaterialSystem->Ortho( 0, 0, m_iViewableWidth, m_iViewableHeight, 0, 1 ); g_pMaterialSystem->Bind( m_pMaterial ); IMesh *pMesh = g_pMaterialSystem->GetDynamicMesh(); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); if (!m_bUseActualSize) { DrawStretchedToPanel( meshBuilder ); } else { DrawActualSize( meshBuilder ); } meshBuilder.End(); pMesh->Draw(); g_pMatSystemSurface->End3DPaint( ); }
void OverlayCameraRenderTarget( const char *pszMaterialName, float flX, float flY, float w, float h ) { float offsetS = ( 0.5f / 256.0f ); float offsetT = ( 0.5f / 256.0f ); IMaterial *pMaterial; pMaterial = materials->FindMaterial( pszMaterialName, TEXTURE_GROUP_OTHER, true ); if( !IsErrorMaterial( pMaterial ) ) { CMatRenderContextPtr pRenderContext( materials ); pRenderContext->Bind( pMaterial ); IMesh* pMesh = pRenderContext->GetDynamicMesh( true ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); meshBuilder.Position3f( flX, flY, 0.0f ); meshBuilder.TexCoord2f( 0, 0.0f + offsetS, 0.0f + offsetT ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( flX+w, flY, 0.0f ); meshBuilder.TexCoord2f( 0, 1.0f + offsetS, 0.0f + offsetT ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( flX+w, flY+h, 0.0f ); meshBuilder.TexCoord2f( 0, 1.0f + offsetS, 1.0f + offsetT ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( flX, flY+h, 0.0f ); meshBuilder.TexCoord2f( 0, 0.0f + offsetS, 1.0f + offsetT ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); } }
void CGWIC_Cell::RandomizeTerrain(float subdelta) { IMesh* pMesh = terrain->getMesh(); s32 Q = static_cast<s32> (subdelta); for (u32 n=0; n<pMesh->getMeshBufferCount(); n++) { IMeshBuffer* pMeshBuffer = pMesh->getMeshBuffer(n); if (pMeshBuffer->getVertexType() != EVT_2TCOORDS) continue; S3DVertex2TCoords* pVertices = (S3DVertex2TCoords*)pMeshBuffer->getVertices(); //1. find the current max & min, since we don't want to escalate landscape float max = 0; float min = 256; u32 i; for (i=0; i<(256*256); i++) { if (pVertices[i].Pos.Y < min) min = pVertices[i].Pos.Y; if (pVertices[i].Pos.Y > max) max = pVertices[i].Pos.Y; } std::cout << "RandTerr: min=" << min << "; max=" << max << std::endl; //2. create temp array & randomize it std::vector<float> tmparr; float cy; for (i=0; i<(256*256); i++) { if (Q) { cy = Random_FLOAT(max-min); cy += min; } else cy = 0; tmparr.push_back(cy); } std::cout << std::endl; //3. interpolate vertices inside big quads s32 A = 0; if (Q) A = 256 / Q + 1; for (int qx=0; qx<A; qx++) for (int qy=0; qy<A; qy++) { //TODO: remove unnecessary vars int x0 = qx * Q; int y0 = qy * Q; int xe = x0 + Q; if (xe > 255) xe = 255; int ye = y0 + Q; if (ye > 255) ye = 255; float hx0 = tmparr[x0*256+y0]; float hy0 = (qx%2)? tmparr[xe*256+ye]:hx0; float hxe = tmparr[xe*256+y0]; float hye = tmparr[x0*256+ye]; float lhy = hye - hy0; float lhx = hxe - hx0; for (int cx=x0; cx<xe; cx++) for (int cy=y0; cy<ye; cy++) { float ch = (((qx%2)?(x0-cx):(cx-x0))/lhx)*lhx+hx0; ch += (((qy%2)?(y0-cy):(cy-y0))/lhy)*lhy+hy0; tmparr[cx*256+cy] = ch / 2; } } //4. get result back for (i=0; i<(256*256); i++) pVertices[i].Pos.Y = tmparr[i]; break; } TerrainChanged(); }
//----------------------------------------------------------------------------- // Purpose: Renders a selection gizmo at our bounds center. // Input : pRender - Rendering interface. //----------------------------------------------------------------------------- void Marker3D::RenderTool3D(CRender3D *pRender) { if (!IsActiveTool()) { return; } Vector *pPos; if (IsTranslating()) { pPos = &m_vecTranslatePos; } else { if (IsEmpty()) { return; } pPos = &m_vecPos; } // // Setup the renderer. // pRender->SetRenderMode(RENDER_MODE_WIREFRAME); CMeshBuilder meshBuilder; IMesh* pMesh = MaterialSystemInterface()->GetDynamicMesh(); meshBuilder.Begin(pMesh, MATERIAL_LINES, 3); meshBuilder.Position3f(g_MIN_MAP_COORD, (*pPos)[1], (*pPos)[2]); meshBuilder.Color3ub(255, 0, 0); meshBuilder.AdvanceVertex(); meshBuilder.Position3f(g_MAX_MAP_COORD, (*pPos)[1], (*pPos)[2]); meshBuilder.Color3ub(255, 0, 0); meshBuilder.AdvanceVertex(); meshBuilder.Position3f((*pPos)[0], g_MIN_MAP_COORD, (*pPos)[2]); meshBuilder.Color3ub(0, 255, 0); meshBuilder.AdvanceVertex(); meshBuilder.Position3f((*pPos)[0], g_MAX_MAP_COORD, (*pPos)[2]); meshBuilder.Color3ub(0, 255, 0); meshBuilder.AdvanceVertex(); meshBuilder.Position3f((*pPos)[0], (*pPos)[1], g_MIN_MAP_COORD); meshBuilder.Color3ub(0, 0, 255); meshBuilder.AdvanceVertex(); meshBuilder.Position3f((*pPos)[0], (*pPos)[1], g_MAX_MAP_COORD); meshBuilder.Color3ub(0, 0, 255); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); pRender->SetRenderMode(RENDER_MODE_DEFAULT); }
void Object2d::setVisible(bool vis) { list<IMesh *>::iterator mesh; for (mesh = m_meshList.begin(); mesh != m_meshList.end(); ++mesh) { IMesh* temp = *mesh; temp->setVisible(vis); } }
static void DispInfo_DrawChainNormals( IDispInfo *pHead ) { #ifndef SWDS #ifdef _DEBUG // Only do it in debug because we're only storing the info then Vector p; materialSystemInterface->Bind( g_pMaterialWireframeVertexColor ); for( IDispInfo *pCur=pHead; pCur; pCur = pCur->GetNextInRenderChain() ) { CDispInfo *pDisp = static_cast<CDispInfo*>( pCur ); int nVerts = pDisp->NumVerts(); IMesh *pMesh = materialSystemInterface->GetDynamicMesh( ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_LINES, nVerts * 3 ); for( int iVert=0; iVert < nVerts; iVert++ ) { CDispRenderVert* pVert = pDisp->GetVertex(iVert); meshBuilder.Position3fv( pVert->m_vPos.Base() ); meshBuilder.Color3ub( 255, 0, 0 ); meshBuilder.AdvanceVertex(); VectorMA( pVert->m_vPos, 5.0f, pVert->m_vNormal, p ); meshBuilder.Position3fv( p.Base() ); meshBuilder.Color3ub( 255, 0, 0 ); meshBuilder.AdvanceVertex(); meshBuilder.Position3fv( pVert->m_vPos.Base() ); meshBuilder.Color3ub( 0, 255, 0 ); meshBuilder.AdvanceVertex(); VectorMA( pVert->m_vPos, 5.0f, pVert->m_vSVector, p ); meshBuilder.Position3fv( p.Base() ); meshBuilder.Color3ub( 0, 255, 0 ); meshBuilder.AdvanceVertex(); meshBuilder.Position3fv( pVert->m_vPos.Base() ); meshBuilder.Color3ub( 0, 0, 255 ); meshBuilder.AdvanceVertex(); VectorMA( pVert->m_vPos, 5.0f, pVert->m_vTVector, p ); meshBuilder.Position3fv( p.Base() ); meshBuilder.Color3ub( 0, 0, 255 ); meshBuilder.AdvanceVertex(); } meshBuilder.End(); pMesh->Draw(); } #endif #endif }
void DrawSmokeFogOverlay() { if(g_SmokeFogOverlayAlpha == 0 || !g_pSmokeFogMaterial || !materials) return; // Hard-coded for now.. g_SmokeFogOverlayColor.Init( 0.3, 0.3, 0.3 ); CMatRenderContextPtr pRenderContext( materials ); pRenderContext->MatrixMode( MATERIAL_PROJECTION ); pRenderContext->LoadIdentity(); pRenderContext->Ortho( 0, 0, 1, 1, -99999, 99999 ); pRenderContext->MatrixMode( MATERIAL_VIEW ); pRenderContext->LoadIdentity(); pRenderContext->MatrixMode( MATERIAL_MODEL ); pRenderContext->LoadIdentity(); IMesh* pMesh = pRenderContext->GetDynamicMesh( false, NULL, NULL, g_pSmokeFogMaterial ); CMeshBuilder meshBuilder; static float dist = 10; Vector vColor = g_SmokeFogOverlayColor; vColor.x = MIN(MAX(vColor.x, 0), 1); vColor.y = MIN(MAX(vColor.y, 0), 1); vColor.z = MIN(MAX(vColor.z, 0), 1); float alpha = MIN(MAX(g_SmokeFogOverlayAlpha, 0), 1); meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); meshBuilder.Position3f( 0, 0, dist ); meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha ); meshBuilder.TexCoord2f( 0, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( 0, 1, dist ); meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha ); meshBuilder.TexCoord2f( 0, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( 1, 1, dist ); meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha ); meshBuilder.TexCoord2f( 0, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( 1, 0, dist ); meshBuilder.Color4f( vColor.x, vColor.y, vColor.z, alpha ); meshBuilder.TexCoord2f( 0, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
IMesh *World::AddMesh(const c8 *meshName) { IMesh *mesh = new Mesh( engine->GetIrrlichtDevice()->getSceneManager(), meshName ); AddTransformable(mesh); mesh->drop(); return mesh; }
//----------------------------------------------------------------------------- // Debugging aid to display a texture //----------------------------------------------------------------------------- static void OverlayShowTexture( const char* textureName, float scale ) { bool foundVar; IMaterial *pMaterial; IMaterialVar *BaseTextureVar; ITexture *pTex; float x, y, w, h; // ___error is created in code in CMaterialSystem::CreateDebugMaterials() pMaterial = materials->FindMaterial( "___error", TEXTURE_GROUP_OTHER, true ); BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false ); if (!foundVar) return; CMatRenderContextPtr pRenderContext( materials ); if ( textureName && textureName[0] ) { pTex = materials->FindTexture( textureName, TEXTURE_GROUP_OTHER, false ); BaseTextureVar->SetTextureValue( pTex ); w = pTex->GetActualWidth() * scale; h = pTex->GetActualHeight() * scale; } else { w = h = 64.0f * scale; } // Center relative to current viewport int nViewportX, nViewportY, nViewportWidth, nViewportHeight; pRenderContext->GetViewport( nViewportX, nViewportY, nViewportWidth, nViewportHeight ); x = ( nViewportWidth - w ) * 0.5f; y = ( nViewportHeight - h ) * 0.5f; pRenderContext->Bind( pMaterial ); IMesh* pMesh = pRenderContext->GetDynamicMesh( true ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); meshBuilder.Position3f( x, y, 0.0f ); meshBuilder.TexCoord2f( 0, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( x+w, y, 0.0f ); meshBuilder.TexCoord2f( 0, 1.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( x+w, y+h, 0.0f ); meshBuilder.TexCoord2f( 0, 1.0f, 1.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( x, y+h, 0.0f ); meshBuilder.TexCoord2f( 0, 0.0f, 1.0f ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
//----------------------------------------------------------------------------- // Purpose: // Input : pMaterial - // source - // color - //----------------------------------------------------------------------------- void DrawHaloOriented( const Vector& source, float scale, float const *color, float roll ) { Vector point, screen; CMatRenderContextPtr pRenderContext( materials ); IMesh* pMesh = pRenderContext->GetDynamicMesh(); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); // Transform source into screen space ScreenTransform( source, screen ); Vector right, up; float sr, cr; SinCos( roll, &sr, &cr ); for ( int i = 0; i < 3; i++ ) { right[i] = CurrentViewRight()[i] * cr + CurrentViewUp()[i] * sr; up[i] = CurrentViewRight()[i] * -sr + CurrentViewUp()[i] * cr; } meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 1); VectorMA (source, -scale, up, point); VectorMA (point, -scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 0); VectorMA (source, scale, up, point); VectorMA (point, -scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 0); VectorMA (source, scale, up, point); VectorMA (point, scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 1); VectorMA (source, -scale, up, point); VectorMA (point, scale, right, point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
bool CModel::LoadMaterial( CXMLElement * pMaterial ) { CXMLAttr * pNameAttr = pMaterial->GetAttr( "Name" ); const char * szMatName = ( NULL != pNameAttr ) ? pNameAttr->GetValue() : NULL; CXMLAttr * pShader = pMaterial->GetAttr( "Shader" ); const char * szShader = ( NULL != pShader ) ? pShader->GetValue() : NULL; if ( !szMatName ) { DEBUG_ASSERT( !"No material name!" ); return false; } // Пробигаем по всем объектам модели, пытаемся найти // нужный материал по имени ( szName ) //for ( uint n = 0; n < m_nNumObjects; ++n ) { //CObject & pObj = m_pObjects[ n ]; IMesh * pMesh = (IMesh *)m_pShape; IMaterial * pNewMaterial = g_pEngine->CreateMaterial(); if ( !pNewMaterial ) { // Ошибка выделения памяти return false; } m_pMaterial = pNewMaterial; pNewMaterial->SetShader( g_pRenderer->GetShader( szShader ) ); for ( uint n = 0; n < pMesh->GetSurfCount(); ++n ) { IMaterial * pSubMat = NULL; if ( CStr::Compare( szMatName, pMesh->GetSurfName( n ) ) ) { pSubMat = g_pEngine->CreateMaterial(); if ( pSubMat ) { //pSubMat->SetShader( g_pRenderer->GetShader( szShader ) ); pSubMat->SetShader( g_pRenderer->GetShader( MESH_SHADER ) ); } } pNewMaterial->AddSubMaterial( pSubMat ); } DEBUG_ASSERT( pNewMaterial->GetSubCount() == pMesh->GetSurfCount() ); } return true; }
//----------------------------------------------------------------------------- // Purpose: Draw the jetpack level //----------------------------------------------------------------------------- void CHudEMP::Paint() { // Rush label int iX, iY; GetPos( iX, iY ); int iWidth = XRES(16); int iHeight = YRES(16); if ( m_pFrameVar ) { float curtime = gpGlobals->curtime; if ( curtime >= m_flNextFrameChange ) { m_flNextFrameChange = curtime + ( 1.0f / HUDEMP_FRAMERATE ); int frame = m_pFrameVar->GetIntValue(); frame++; if ( frame >= m_nNumFrames ) { frame = 0; } m_pFrameVar->SetIntValue(frame); } } IMesh* pMesh = materials->GetDynamicMesh( true, NULL, NULL, m_pEMPIcon ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); meshBuilder.Color3f( 1.0, 1.0, 1.0 ); meshBuilder.TexCoord2f( 0,0,0 ); meshBuilder.Position3f( iX,iY,0 ); meshBuilder.AdvanceVertex(); meshBuilder.Color3f( 1.0, 1.0, 1.0 ); meshBuilder.TexCoord2f( 0,1,0 ); meshBuilder.Position3f( iX+iWidth, iY, 0 ); meshBuilder.AdvanceVertex(); meshBuilder.Color3f( 1.0, 1.0, 1.0 ); meshBuilder.TexCoord2f( 0,1,1 ); meshBuilder.Position3f( iX+iWidth, iY+iHeight, 0 ); meshBuilder.AdvanceVertex(); meshBuilder.Color3f( 1.0, 1.0, 1.0 ); meshBuilder.TexCoord2f( 0,0,1 ); meshBuilder.Position3f( iX, iY+iHeight, 0 ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
//----------------------------------------------------------------------------- // Purpose: // Input : pMaterial - // source - // color - //----------------------------------------------------------------------------- void DrawHalo(IMaterial* pMaterial, const Vector& source, float scale, float const* color, float flHDRColorScale ) { static unsigned int nHDRColorScaleCache = 0; Vector point, screen; if( pMaterial ) { IMaterialVar *pHDRColorScaleVar = pMaterial->FindVarFast( "$hdrcolorscale", &nHDRColorScaleCache ); if( pHDRColorScaleVar ) { pHDRColorScaleVar->SetFloatValue( flHDRColorScale ); } } CMatRenderContextPtr pRenderContext( materials ); IMesh* pMesh = pRenderContext->GetDynamicMesh( ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); // Transform source into screen space ScreenTransform( source, screen ); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 1); VectorMA (source, -scale, CurrentViewUp(), point); VectorMA (point, -scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 0, 0); VectorMA (source, scale, CurrentViewUp(), point); VectorMA (point, -scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 0); VectorMA (source, scale, CurrentViewUp(), point); VectorMA (point, scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv (color); meshBuilder.TexCoord2f (0, 1, 1); VectorMA (source, -scale, CurrentViewUp(), point); VectorMA (point, scale, CurrentViewRight(), point); meshBuilder.Position3fv (point.Base()); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
//------------------------------------- // Loads in a mesh from a file and returns it // p1 in - pointer to the meshdata for the mesh // rv - pointer IMesh object and nullptr if failed IMesh *CRendererOpenGL::LoadMesh(MeshData* md) { IMesh *pMesh = new CMeshOpenGL(); if( !pMesh->Load(md) ) { delete pMesh; return nullptr; } m_vpMeshes.push_back(pMesh); return pMesh; }
//----------------------------------------------------------------------------- // Purpose: Renders the connecting lines between the keyframes // Input : pRender - //----------------------------------------------------------------------------- void CMapKeyFrame::Render3D( CRender3D *pRender ) { if ( m_bRebuildPath ) { if (GetAnimator() != NULL) { GetAnimator()->RebuildPath(); } } // only draw if we have a valid connection if ( m_pNextKeyFrame && m_flSpeed > 0 ) { // only draw if we haven't already been drawn this frame if ( GetRenderFrame() != pRender->GetRenderFrame() ) { pRender->PushRenderMode( RENDER_MODE_WIREFRAME ); SetRenderFrame( pRender->GetRenderFrame() ); Vector o1, o2; GetOrigin( o1 ); m_pNextKeyFrame->GetOrigin( o2 ); CMeshBuilder meshBuilder; CMatRenderContextPtr pRenderContext( MaterialSystemInterface() ); IMesh *pMesh = pRenderContext->GetDynamicMesh(); // draw connecting line going from green to red meshBuilder.Begin( pMesh, MATERIAL_LINE_STRIP, MAX_LINE_POINTS ); // start point meshBuilder.Color3f( 0, 1.0f, 0 ); meshBuilder.Position3f( o1[0], o1[1], o1[2] ); meshBuilder.AdvanceVertex(); for ( int i = 0; i < MAX_LINE_POINTS; i++ ) { float red = (float)(i+1) / (float)MAX_LINE_POINTS; meshBuilder.Color3f( red, 1.0f - red, 0 ); meshBuilder.Position3f( m_LinePoints[i][0], m_LinePoints[i][1], m_LinePoints[i][2] ); meshBuilder.AdvanceVertex(); } meshBuilder.End(); pMesh->Draw(); pRender->PopRenderMode(); } } }
//----------------------------------------------------------------------------- // Purpose: // Input : frame - // x - // y - // *prcSubRect - //----------------------------------------------------------------------------- void CEngineSprite::DrawFrameOfSize( int frame, int x, int y, int iWidth, int iHeight, const wrect_t *prcSubRect ) { // FIXME: If we ever call this with AVIs, need to have it call GetTexCoordRange and make that work Assert( !IsAVI() && !IsBIK() ); float fLeft = 0; float fRight = 1; float fTop = 0; float fBottom = 1; if ( prcSubRect ) { AdjustSubRect( this, frame, &fLeft, &fRight, &fTop, &fBottom, &iWidth, &iHeight, prcSubRect ); } if ( giScissorTest && !Scissor( x, y, iWidth, iHeight, fLeft, fTop, fRight, fBottom ) ) return; SetFrame( frame ); CMatRenderContextPtr pRenderContext( materials ); IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, GetMaterial() ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); float color[3]; GetHUDSpriteColor( color ); meshBuilder.Color3fv( color ); meshBuilder.TexCoord2f( 0, fLeft, fTop ); meshBuilder.Position3f( x, y, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv( color ); meshBuilder.TexCoord2f( 0, fRight, fTop ); meshBuilder.Position3f( x + iWidth, y, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv( color ); meshBuilder.TexCoord2f( 0, fRight, fBottom ); meshBuilder.Position3f( x + iWidth, y + iHeight, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Color3fv( color ); meshBuilder.TexCoord2f( 0, fLeft, fBottom ); meshBuilder.Position3f( x, y + iHeight, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
//----------------------------------------------------------------------------- // Debugging aid to display a texture //----------------------------------------------------------------------------- static void OverlayShowTexture( const char* textureName, float scale ) { bool foundVar; IMaterial *pMaterial; IMaterialVar *BaseTextureVar; ITexture *pTex; float x, y, w, h; // screen safe x = 32; y = 32; pMaterial = materials->FindMaterial( "___debug", TEXTURE_GROUP_OTHER, true ); BaseTextureVar = pMaterial->FindVar( "$basetexture", &foundVar, false ); if (!foundVar) return; CMatRenderContextPtr pRenderContext( materials ); if ( textureName && textureName[0] ) { pTex = materials->FindTexture( textureName, TEXTURE_GROUP_OTHER, false ); BaseTextureVar->SetTextureValue( pTex ); w = pTex->GetActualWidth() * scale; h = pTex->GetActualHeight() * scale; } else { w = h = 64.0f * scale; } pRenderContext->Bind( pMaterial ); IMesh* pMesh = pRenderContext->GetDynamicMesh( true ); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); meshBuilder.Position3f( x, y, 0.0f ); meshBuilder.TexCoord2f( 0, 0.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( x+w, y, 0.0f ); meshBuilder.TexCoord2f( 0, 1.0f, 0.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( x+w, y+h, 0.0f ); meshBuilder.TexCoord2f( 0, 1.0f, 1.0f ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( x, y+h, 0.0f ); meshBuilder.TexCoord2f( 0, 0.0f, 1.0f ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
TEST(Mesh, topoN2N) { IMesh* msh = MeshGenerator::generateStructuredRegularQuadMesh(2.0, 2, .0, .0, .0); TopologyNode2NodesConnectedByEdges topo_node2nodes(*msh); ASSERT_EQ(topo_node2nodes.getNumberOfNodes(), msh->getNumberOfNodes()); // size_t expected_conn_nodes0[] = {1,3}; // size_t expected_conn_nodes1[] = {0,2,4}; // size_t expected_conn_nodes4[] = {1,3,5,7}; // ASSERT_EQ(std::set<size_t>(expected_conn_nodes0, expected_conn_nodes0+2), topo_node2nodes.getConnectedNodes(0)); // ASSERT_EQ(std::set<size_t>(expected_conn_nodes1, expected_conn_nodes1+3), topo_node2nodes.getConnectedNodes(1)); // ASSERT_EQ(std::set<size_t>(expected_conn_nodes4, expected_conn_nodes4+4), topo_node2nodes.getConnectedNodes(4)); }
/* ================================= */ bool doit (void* ctx, commit_pipe* obj) { IMesh* mesh; size_t size; IAttrib* attr; commit_unit* list; crh3d9_cmmt_ctx* parm; if (obj->effect != NULL) obj->effect->enter(); size = obj->stuffz.size(); list = obj->stuffz.data(); parm = (crh3d9_cmmt_ctx*)ctx; for (size_t idx = 0; idx < size; idx++) { if (parm->inst != list->inst) { parm->inst = list->inst; if (list->inst->flag == INST_FLAG_BILLBOARDV) { mem_cpy(parm->main->get_mat<fp32_t>(), &parm->bllv, sizeof(mat4x4_t)); parm->main->mul_mat(&list->inst->tran); parm->devs->SetTransform(D3DTS_WORLD, parm->main->get_mat<D3DMATRIX>()); } else if (list->inst->flag == INST_FLAG_BILLBOARDH) { mem_cpy(parm->main->get_mat<fp32_t>(), &parm->bllh, sizeof(mat4x4_t)); parm->main->mul_mat(&list->inst->tran); parm->devs->SetTransform(D3DTS_WORLD, parm->main->get_mat<D3DMATRIX>()); } else { parm->devs->SetTransform(D3DTS_WORLD, (D3DMATRIX*)(&list->inst->tran)); } } attr = list->unit->attr; if (attr != NULL) { attr->commit(); parm->nv += attr->get_vnum(); parm->nt += attr->get_tnum(); } if (list->unit->mesh != NULL) { for (size_t ii = 0; ; ii++) { mesh = list->unit->mesh[ii]; if (mesh == NULL) break; mesh->commit(); parm->nv += mesh->get_vnum(); parm->nt += mesh->get_tnum(); } } list += 1; } return (true); }
//----------------------------------------------------------------------------- // Purpose: // Input : pRender - //----------------------------------------------------------------------------- void CMapLine::Render3D(CRender3D *pRender) { if ( (m_pStartEntity == NULL) || (m_pEndEntity == NULL) ) return; pRender->BeginRenderHitTarget(this); pRender->PushRenderMode(RENDER_MODE_WIREFRAME); Vector Start, End; m_pStartEntity->GetOrigin(Start); m_pEndEntity->GetOrigin(End); CMeshBuilder meshBuilder; CMatRenderContextPtr pRenderContext( MaterialSystemInterface() ); IMesh* pMesh = pRenderContext->GetDynamicMesh(); // FIXME: Can't do this...! glLineWidth(2); meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 ); unsigned char color[3]; if (IsSelected()) { color[0] = SELECT_EDGE_RED; color[1] = SELECT_EDGE_GREEN; color[2] = SELECT_EDGE_BLUE; } else { color[0] = r; color[1] = g; color[2] = b; } meshBuilder.Color3ubv( color ); meshBuilder.Position3f(Start.x, Start.y, Start.z); meshBuilder.AdvanceVertex(); meshBuilder.Color3ubv( color ); meshBuilder.Position3f(End.x, End.y, End.z); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); pRender->EndRenderHitTarget(); pRender->PopRenderMode(); }
void FX_DrawLine( const Vector &start, const Vector &end, float scale, IMaterial *pMaterial, const color32 &color ) { Vector lineDir, viewDir; //Get the proper orientation for the line VectorSubtract( end, start, lineDir ); VectorSubtract( end, CurrentViewOrigin(), viewDir ); Vector cross = lineDir.Cross( viewDir ); VectorNormalize( cross ); CMatRenderContextPtr pRenderContext( materials ); //Bind the material IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, pMaterial ); CMeshBuilder meshBuilder; Vector tmp; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); VectorMA( start, -scale, cross, tmp ); meshBuilder.Position3fv( tmp.Base() ); meshBuilder.TexCoord2f( 0, 1.0f, 1.0f ); meshBuilder.Color4ub( color.r, color.g, color.b, color.a ); meshBuilder.Normal3fv( cross.Base() ); meshBuilder.AdvanceVertex(); VectorMA( start, scale, cross, tmp ); meshBuilder.Position3fv( tmp.Base() ); meshBuilder.TexCoord2f( 0, 0.0f, 1.0f ); meshBuilder.Color4ub( color.r, color.g, color.b, color.a ); meshBuilder.Normal3fv( cross.Base() ); meshBuilder.AdvanceVertex(); VectorMA( end, scale, cross, tmp ); meshBuilder.Position3fv( tmp.Base() ); meshBuilder.TexCoord2f( 0, 0.0f, 0.0f ); meshBuilder.Color4ub( color.r, color.g, color.b, color.a ); meshBuilder.Normal3fv( cross.Base() ); meshBuilder.AdvanceVertex(); VectorMA( end, -scale, cross, tmp ); meshBuilder.Position3fv( tmp.Base() ); meshBuilder.TexCoord2f( 0, 1.0f, 0.0f ); meshBuilder.Color4ub( color.r, color.g, color.b, color.a ); meshBuilder.Normal3fv( cross.Base() ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); }
void Entity::updateRenderable(MeshHandle meshHandle) { clearAllRenderable(); IMesh *pMesh = gEngModule->pMeshMgr->getDataPtr(meshHandle); const SubMeshVec &subMeshVec = pMesh->getSubMeshVec(); for (int i = 0; i < subMeshVec.size(); ++i) { Renderable *pRenderable = new StaticRenderable(meshHandle, i); addRenderable(pRenderable); std::string mtlName = subMeshVec[i].mtlName; IMaterial *pMaterial = gEngModule->pMaterialMgr->create("res/mesh/" + mtlName); pRenderable->setMaterial(gEngModule->pMaterialMgr->getHandle(pMaterial->getName())); } }
void drawFloor () { float mTempModel[4][4]; float mTempView[4][4]; g_pMaterialSystem->Bind(g_materialFloor); g_pMaterialSystem->MatrixMode(MATERIAL_MODEL); g_pMaterialSystem->GetMatrix(MATERIAL_MODEL, (float*)mTempModel); g_pMaterialSystem->LoadIdentity(); g_pMaterialSystem->MatrixMode(MATERIAL_VIEW); g_pMaterialSystem->GetMatrix(MATERIAL_VIEW, (float*)mTempView); g_pMaterialSystem->LoadIdentity(); { IMesh* pMesh = g_pMaterialSystem->GetDynamicMesh(); CMeshBuilder meshBuilder; meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 ); float dist=-15000.0f; float tMin=0, tMax=1; meshBuilder.Position3f(-dist, dist, dist); meshBuilder.TexCoord2f( 0, tMin,tMax ); meshBuilder.Color4ub( 255, 255, 255, 255 ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( dist, dist, dist); meshBuilder.TexCoord2f( 0, tMax,tMax ); meshBuilder.Color4ub( 255, 255, 255, 255 ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f( dist,-dist, dist); meshBuilder.TexCoord2f( 0, tMax,tMin ); meshBuilder.Color4ub( 255, 255, 255, 255 ); meshBuilder.AdvanceVertex(); meshBuilder.Position3f(-dist,-dist, dist); meshBuilder.TexCoord2f( 0, tMin,tMin ); meshBuilder.Color4ub( 255, 255, 255, 255 ); meshBuilder.AdvanceVertex(); meshBuilder.End(); pMesh->Draw(); } g_pMaterialSystem->MatrixMode(MATERIAL_MODEL); g_pMaterialSystem->LoadMatrix((float*)mTempModel); g_pMaterialSystem->MatrixMode(MATERIAL_VIEW); g_pMaterialSystem->LoadMatrix((float*)mTempView); }
//! Reads attributes of the scene node. void CMeshSceneNode::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options) { io::path oldMeshStr = SceneManager->getMeshCache()->getMeshName(Mesh); io::path newMeshStr = in->getAttributeAsString("Mesh"); ReadOnlyMaterials = in->getAttributeAsBool("ReadOnlyMaterials"); if (newMeshStr != "" && oldMeshStr != newMeshStr) { IMesh* newMesh = 0; IAnimatedMesh* newAnimatedMesh = SceneManager->getMesh(newMeshStr.c_str()); if (newAnimatedMesh) newMesh = newAnimatedMesh->getMesh(0); if (newMesh) setMesh(newMesh); } // optional attribute to assign the hint to the whole mesh if (in->existsAttribute("HardwareMappingHint") && in->existsAttribute("HardwareMappingBufferType")) { scene::E_HARDWARE_MAPPING mapping = scene::EHM_NEVER; scene::E_BUFFER_TYPE bufferType = scene::EBT_NONE; core::stringc smapping = in->getAttributeAsString("HardwareMappingHint"); if (smapping.equals_ignore_case("static")) mapping = scene::EHM_STATIC; else if (smapping.equals_ignore_case("dynamic")) mapping = scene::EHM_DYNAMIC; else if (smapping.equals_ignore_case("stream")) mapping = scene::EHM_STREAM; core::stringc sbufferType = in->getAttributeAsString("HardwareMappingBufferType"); if (sbufferType.equals_ignore_case("vertex")) bufferType = scene::EBT_VERTEX; else if (sbufferType.equals_ignore_case("index")) bufferType = scene::EBT_INDEX; else if (sbufferType.equals_ignore_case("vertexindex")) bufferType = scene::EBT_VERTEX_AND_INDEX; IMesh* mesh = getMesh(); if (mesh) mesh->setHardwareMappingHint(mapping, bufferType); } IMeshSceneNode::deserializeAttributes(in, options); }
void RenderMotionBlur() { mRenderer->VSetRenderContextTargetWithDepth(mRenderContext, 0); mRenderer->VClearContext(mRenderContext, reinterpret_cast<const float*>(&mClearColor), 1.0f, 0); mRenderer->VSetInputLayout(mVertexShader); mRenderer->VSetVertexShader(mVertexShader); // mRenderer->VSetPixelShader(mPixelShader); mRenderer->VSetPixelShader(mSCPixelShader); DrawScene(); mRenderer->VSetContextTargetWithDepth(); mRenderer->VClearContext(reinterpret_cast<const float*>(&mClearColor), 1.0f, 0); mRenderer->VSetInputLayout(mQuadVertexShader); mRenderer->VSetVertexShader(mQuadVertexShader); mRenderer->VSetPixelShader(mMotionBlurPixelShader); mRenderer->VUpdateShaderConstantBuffer(mBlurShaderResource, &mMBMatrixBuffer, 0); mRenderer->VSetPixelShaderConstantBuffer(mBlurShaderResource, 0, 0); mRenderer->VSetPixelShaderResourceView(mRenderContext, 0, 0); mRenderer->VSetPixelShaderDepthResourceView(mRenderContext, 1); mRenderer->VSetPixelShaderSamplerStates(mBlurShaderResource); mRenderer->VBindMesh(mQuadMesh); mRenderer->VDrawIndexed(0, mQuadMesh->GetIndexCount()); ID3D11DeviceContext* deviceContext = mRenderer->GetDeviceContext(); ID3D11ShaderResourceView* nullSRV[2] = { 0, 0 }; deviceContext->PSSetShaderResources(0, 2, nullSRV); }
IAnimatedMesh* CMeshManager::getAnimatedMesh(const std::string& name, bool bLoadIfNotExist) { auto it = mMeshMap.find(name); IMesh* mesh = nullptr; if (it != mMeshMap.end()) mesh = it->second; else if (bLoadIfNotExist) mesh = IResourceGroupManager::getInstance()->loadMesh(name); if (mesh && mesh->getType() == EMT_ANIMATE_MODEL_MESH) { return dynamic_cast<IAnimatedMesh*>(mesh); } return nullptr; }