global func CreateBurnMark(int iX, int iY, int iLevel, int Count) { var boom; if(!ObjectCount(BOOM)) boom = CreateObject(BOOM,0,0,-1); else boom = FindObject(BOOM); var angle=Random(360/Count); //variablen für die überprüfung var type; for(var z; z < Count; z++) { angle += Max(1,360/Count); // Check: Sky or Solid/Liquid var x = iX+Cos(angle,iLevel); var y = iY+Sin(angle,iLevel); if((GetMaterialVal("Density","Material",GetMaterial(x,y)) != 0) || (GetMaterial(x,y) == -1)) continue; type = 1+Random(3); var size = BurnMarkCheck(angle,RandomX(iLevel/2,iLevel*2),iX,iY); var sin = Sin(angle,(size-iLevel)/2+iLevel+Random(3)); var cos = Cos(angle,(size-iLevel)/2+iLevel+Random(3)); CreateParticle("BurnMark",iX+cos,iY+sin,Cos(angle+RandomX(-5,5),50),Sin(angle+RandomX(-5,5),50),size*5+Random(25),RGBa(0,0,0,64),boom,1); } }
void PointCloud::NotifyMouseClicked( const Events::MouseEvent& event ) { // If we are scrolling == Zooming if(event.GetType() == Events::MouseEventType::SCROLL_DOWN) { glm::vec3 cameraPosition = Atum::SceneManager::SceneManager::GetInstance().GetCurrentScene()->GetCurrentCamera()->GetPosition(); glm::vec3 objectPosition = m_transform.GetPosition(); float distance = glm::length(objectPosition - cameraPosition); float pointSize = 20.0f/(distance+1.0f); LowLevelGraphics::LowLevelAPI::BindShaders(GetMaterial()->GetShaderList()); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("pointSize", &pointSize, SHADER_FLOAT); } else if(event.GetType() == Events::MouseEventType::SCROLL_UP) { glm::vec3 cameraPosition = Atum::SceneManager::SceneManager::GetInstance().GetCurrentScene()->GetCurrentCamera()->GetPosition(); glm::vec3 objectPosition = m_transform.GetPosition(); float distance = glm::length(objectPosition - cameraPosition); float pointSize = 20.0f/(distance+1.0f); LowLevelGraphics::LowLevelAPI::BindShaders(GetMaterial()->GetShaderList()); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("pointSize", &pointSize, SHADER_FLOAT); } LowLevelGraphics::ShaderProgram::UpdateGlobalShaderParameter(LowLevelGraphics::VIEWMATRIX, glm::value_ptr(Atum::SceneManager::SceneManager::GetInstance().GetCurrentScene()->GetCurrentCamera()->GetViewMatrix()), SHADER_MATRIX44); }
/* ============ idMapPatch::Write ============ */ bool idMapPatch::Write( idFile *fp, int primitiveNum, const idVec3 &origin ) const { int i, j; const idDrawVert *v; if ( GetExplicitlySubdivided() ) { fp->WriteFloatString( "// primitive %d\n{\n patchDef3\n {\n", primitiveNum ); fp->WriteFloatString( " \"%s\"\n ( %d %d %d %d 0 0 0 )\n", GetMaterial(), GetWidth(), GetHeight(), GetHorzSubdivisions(), GetVertSubdivisions()); } else { fp->WriteFloatString( "// primitive %d\n{\n patchDef2\n {\n", primitiveNum ); fp->WriteFloatString( " \"%s\"\n ( %d %d 0 0 0 )\n", GetMaterial(), GetWidth(), GetHeight()); } fp->WriteFloatString( " (\n" ); for ( i = 0; i < GetWidth(); i++ ) { fp->WriteFloatString( " ( " ); for ( j = 0; j < GetHeight(); j++ ) { v = &verts[ j * GetWidth() + i ]; fp->WriteFloatString( " ( %f %f %f %f %f )", v->xyz[0] + origin[0], v->xyz[1] + origin[1], v->xyz[2] + origin[2], v->st[0], v->st[1] ); } fp->WriteFloatString( " )\n" ); } fp->WriteFloatString( " )\n }\n}\n" ); return true; }
global func MaterialDepthCheck(int x, int y, string mat, int depth) { var travelled; var xval = x; var yval = y; //If depth is equal to zero, the function will always measure the depth of the material. //If depth is not equal to zero, the function will return true if the material is as deep or deeper than depth (in pixels). if (depth == nil) depth = LandscapeHeight(); while (travelled != depth) { if (GetMaterial(xval, yval) == Material(mat)) { travelled++; yval++; } if (GetMaterial(xval, yval) != Material(mat)) return travelled; // Returns depth of material. } if (travelled == depth) return true; return false; }
KVIonRangeTableMaterial *KVIonRangeTable::GetMaterialWithPointer(TGeoMaterial *material) { // Returns pointer to material for given TGeoMaterial // We try both the name and the title of the TGeoMaterial KVIonRangeTableMaterial *mat = GetMaterial(material->GetTitle()); if(!mat) mat = GetMaterial(material->GetName()); return mat; }
RefTargetHandle PFOperatorMaterialStatic::Clone(RemapDir &remap) { PFOperatorMaterialStatic* newOp = new PFOperatorMaterialStatic(); newOp->ReplaceReference(0, remap.CloneRef(pblock())); if (GetMaterial() != NULL) newOp->SetMaterial(GetMaterial()); BaseClone(this, newOp, remap); return newOp; }
/* * Better EarthObj Placement. Besides many new parameters it also does the following: * - Leaves at least 10 pixels distance between each placed object * - Makes sure they are *really* stuck in the material * Parameters: * * objectid: Object to be placed * quantity: Quantity to be planted * rect: Target rect as array [x,y,wdt,hgt], Offset in local calls * materials: array of materials it should be placed in. If not set, the objects will be placed in Materials with Soil=1 * nearbymaterials: material the object has to be somewhat close to * * Returns: * Amount of actually placed objects (algo gives up after 10.000 iterations) * * Examples: * * PlaceObjects2(FLNT, 20, 0, LandscapeHeight()/3, LandscapeWidth(), LandscapeHeight()/3, ["Rock", "Granite"]) * - Places 20 flints inside rock and granite between 33% and 66% landscape height */ global func PlaceObjects2(id objectid, int quantity, array rect, array inmaterials, int nearbymaterial) { var x = rect[0], y = rect[1], wdt = rect[2], hgt = rect[3]; var haveinmaterials = GetType(inmaterials) == C4V_Array; // Failsafe var attempts = 0; var placed = 0; // Create a dozen random places and try there var rndx, rndy, valid, obj, matatpos; var objhgt = GetDefHeight(objectid); if (nearbymaterial) { while (quantity > 0 && attempts++ < 20000) { rndx = x + Random(wdt); rndy = y + Random(hgt); matatpos = GetMaterial(rndx,rndy); if (matatpos == nearbymaterial) { for (var i = 0; i < 8; i++) { // Generate a random number between -10 to -4 or 4 to 10 rndx += RandomX(10, 20) * (Random(2)*2-1); rndy += RandomX(10, 20) * (Random(2)*2-1); matatpos = GetMaterial(rndx,rndy); valid = false; if (haveinmaterials) { for (var mat in inmaterials) { if (mat == matatpos && mat != nearbymaterial) { valid = true; break; } } } else { valid = isMaterialSoil(rndx, rndy); } if (valid) { obj = CreateObject(objectid, rndx, rndy + objhgt / 2, -1); obj->SetR(Random(360)); } if (Stuck(obj)) { placed++; quantity--; break; } else { RemoveObject(obj); } } } } } else {
void PointCloud::UpdatePropertyList(const PropertyList& i_properties ) { Object::UpdatePropertyList( i_properties ); //update the parent properties //update the child properties // Binds the correct shader before updating : LowLevelGraphics::LowLevelAPI::BindShaders(GetMaterial()->GetShaderList()); const Property* xMin = i_properties.GetProperty(POINTCLOUD_XMIN_NAME); if (xMin) { xMin->GetValue(m_xMin); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("xMin", &m_xMin, SHADER_FLOAT); } const Property* xMax = i_properties.GetProperty(POINTCLOUD_XMAX_NAME); if (xMax) { xMax->GetValue(m_xMax); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("xMax", &m_xMax, SHADER_FLOAT); } const Property* yMin = i_properties.GetProperty(POINTCLOUD_YMIN_NAME); if (yMin) { yMin->GetValue(m_yMin); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("yMin", &m_yMin, SHADER_FLOAT); } const Property* yMax = i_properties.GetProperty(POINTCLOUD_YMAX_NAME); if (yMax) { yMax->GetValue(m_yMax); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("yMax", &m_yMax, SHADER_FLOAT); } const Property* zMin = i_properties.GetProperty(POINTCLOUD_ZMIN_NAME); if (zMin) { zMin->GetValue(m_zMin); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("zMin", &m_zMin, SHADER_FLOAT); } const Property* zMax = i_properties.GetProperty(POINTCLOUD_ZMAX_NAME); if (zMax) { zMax->GetValue(m_zMax); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("zMax", &m_zMax, SHADER_FLOAT); } const Property* distanceViewPlane = i_properties.GetProperty(POINTCLOUD_DISTANCEVIEWPLANE_NAME); if (distanceViewPlane) { distanceViewPlane->GetValue(m_distanceViewPlane); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("distanceViewPlane", &m_distanceViewPlane, SHADER_FLOAT); } const Property* contraction = i_properties.GetProperty(POINTCLOUD_DISTANCESHELLSPHERE_NAME); if (contraction) { contraction->GetValue(m_distanceShellSphere); GetMaterial()->GetShaderList()->GetShaderProgram()->UpdateShaderParameterWithName("distanceShellSphere", &m_distanceShellSphere, SHADER_FLOAT); } }
inline static IGameMaterial* GetMaterial(size_t& index, IGameMaterial* pRootMat, IGameMaterial* pParent, int nChildID, IGameMaterial** pParentRet, int* pChildIDRet) { BEATS_ASSERT(pRootMat != NULL); BEATS_ASSERT(pParentRet != NULL); if(index == 0 && !pRootMat->IsMultiType()) { *pParentRet = pParent; *pChildIDRet = nChildID; return pRootMat; } else if(index == 0 && pRootMat->IsMultiType()) { int nSubMatCnt = pRootMat->GetSubMaterialCount(); for(int x = 0; x < nSubMatCnt; x++) { IGameMaterial* pSubMat = pRootMat->GetSubMaterial(x); pSubMat = GetMaterial(index, pSubMat, pRootMat, x, pParentRet, pChildIDRet); if(pSubMat != NULL) return pSubMat; } } else if(index != 0 && !pRootMat->IsMultiType()) { index--; int nSubMatCnt = pRootMat->GetSubMaterialCount(); for(int x = 0; x<nSubMatCnt; x++) { IGameMaterial* pSubMat = pRootMat->GetSubMaterial(x); pSubMat = GetMaterial(index, pSubMat, pRootMat, x, pParentRet, pChildIDRet); if(pSubMat != NULL) return pSubMat; } } else { int nSubMatCnt = pRootMat->GetSubMaterialCount(); for(int x = 0; x < nSubMatCnt; x++) { IGameMaterial* pSubMat = pRootMat->GetSubMaterial(x); pSubMat = GetMaterial(index, pSubMat, pRootMat, x, pParentRet, pChildIDRet); if(pSubMat != NULL) return pSubMat; } } return NULL; }
void CGameMtlLibrary::NameToMtlPair (LPCSTR name, int& mtl0, int& mtl1) { string256 buf0, buf1; if (_GetItemCount(name,'\\')<2){ mtl0 = GAMEMTL_NONE_ID; mtl1 = GAMEMTL_NONE_ID; return; } _GetItem (name,0,buf0,'\\'); _GetItem (name,1,buf1,'\\'); _ChangeSymbol (buf0,'/','\\'); _ChangeSymbol (buf1,'/','\\'); SGameMtl* M0 = GetMaterial(buf0); mtl0=M0?M0->GetID():GAMEMTL_NONE_ID; SGameMtl* M1 = GetMaterial(buf1); mtl1=M1?M1->GetID():GAMEMTL_NONE_ID; }
void CPlayerViewProxy::OnBind( void *pC_BaseEntity ) { if (!pC_BaseEntity) return; // Find the view angle between the player and this entity.... C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity ); C_BaseEntity* pPlayer = C_BasePlayer::GetLocalPlayer(); if (!pPlayer) return; Vector delta; VectorSubtract( pEntity->WorldSpaceCenter(), pPlayer->WorldSpaceCenter(), delta ); VectorNormalize( delta ); Vector forward; AngleVectors( pPlayer->GetAbsAngles(), &forward ); Assert( m_pResult ); SetFloatResult( DotProduct( forward, delta ) * m_Factor ); if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
void UDebugSkelMeshComponent::SetShowBoneWeight(bool bNewShowBoneWeight) { // Check we are actually changing it! if(bNewShowBoneWeight == bDrawBoneInfluences) { return; } // if turning on this mode if(bNewShowBoneWeight) { SkelMaterials.Empty(); int32 NumMaterials = GetNumMaterials(); for (int32 i=0; i<NumMaterials; i++) { // Back up old material SkelMaterials.Add(GetMaterial(i)); // Set special bone weight material SetMaterial(i, GEngine->BoneWeightMaterial); } } // if turning it off else { int32 NumMaterials = GetNumMaterials(); check(NumMaterials == SkelMaterials.Num()); for (int32 i=0; i<NumMaterials; i++) { // restore original material SetMaterial(i, SkelMaterials[i]); } } bDrawBoneInfluences = bNewShowBoneWeight; }
Ogre::MaterialPtr Renderer::GetMaterialCopy(const String& originalName, const String& newName) { Ogre::MaterialPtr material = GetMaterial(originalName); if (material.isNull()) return material; return material->clone(newName); }
//TODO: need refine!!! void ctLineBorders::Draw() { //if(!rectDotIndexes) return; //glDisable(GL_DEPTH_TEST); GetOpenGLContext()->functions()->glBindBuffer(GL_ARRAY_BUFFER, meshVBO); if (posAtribLoc != -1) { GetOpenGLContext()->functions()->glVertexAttribPointer(posAtribLoc, 3, GL_FLOAT, GL_FALSE, (3 * sizeof(GLfloat)), (const GLvoid*)0); GetOpenGLContext()->functions()->glEnableVertexAttribArray(posAtribLoc); } else {qDebug()<<"isShit pos!!!";} m_currentShader->bind(); m_currentShader->setUniformValue(matrixUniform, GetProjectionMatrix().GetMatrix()); m_currentShader->setUniformValue(materialUniform, GetMaterial()->GetRGBA()); m_currentShader->setUniformValue(transformMatrixUniform, GetTransform()->GetGlobalTransformMatrix().GetMatrix()); glDrawElements(GL_LINE_LOOP, m_dots.count(), GL_UNSIGNED_SHORT, planeIndexes); GetOpenGLContext()->functions()->glBindBuffer(GL_ARRAY_BUFFER, 0); m_currentShader->release(); }
void CWrapMinMaxProxy::OnBind( void *pC_BaseEntity ) { Assert( m_pSrc1 && m_pResult ); if ( m_flMaxVal.GetFloat() <= m_flMinVal.GetFloat() ) // Bad input, just return the min { SetFloatResult( m_flMinVal.GetFloat() ); } else { float flResult = ( m_pSrc1->GetFloatValue() - m_flMinVal.GetFloat() ) / ( m_flMaxVal.GetFloat() - m_flMinVal.GetFloat() ); if ( flResult >= 0.0f ) { flResult -= ( float )( int )flResult; } else // Negative { flResult -= ( float )( ( ( int )flResult ) - 1 ); } flResult *= ( m_flMaxVal.GetFloat() - m_flMinVal.GetFloat() ); flResult += m_flMinVal.GetFloat(); SetFloatResult( flResult ); } if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
void CSubtractProxy::OnBind( void *pC_BaseEntity ) { Assert( m_pSrc1 && m_pSrc2 && m_pResult ); MaterialVarType_t resultType; int vecSize; ComputeResultType( resultType, vecSize ); switch( resultType ) { case MATERIAL_VAR_TYPE_VECTOR: { Vector a, b, c; m_pSrc1->GetVecValue( a.Base(), vecSize ); m_pSrc2->GetVecValue( b.Base(), vecSize ); VectorSubtract( a, b, c ); m_pResult->SetVecValue( c.Base(), vecSize ); } break; case MATERIAL_VAR_TYPE_FLOAT: SetFloatResult( m_pSrc1->GetFloatValue() - m_pSrc2->GetFloatValue() ); break; case MATERIAL_VAR_TYPE_INT: m_pResult->SetFloatValue( m_pSrc1->GetIntValue() - m_pSrc2->GetIntValue() ); break; } if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
void CExponentialProxy::OnBind( void *pC_BaseEntity ) { float flVal = m_Scale.GetFloat() * exp(m_pSrc1->GetFloatValue( ) + m_Offset.GetFloat()); float flMaxVal = m_flMaxVal.GetFloat(); float flMinVal = m_flMinVal.GetFloat(); if (flMinVal > flMaxVal) { float flTemp = flMinVal; flMinVal = flMaxVal; flMaxVal = flTemp; } // clamp if (flVal < flMinVal) flVal = flMinVal; else if ( flVal > flMaxVal ) flVal = flMaxVal; SetFloatResult( flVal ); if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
void CGaussianNoiseProxy::OnBind( void *pC_BaseEntity ) { float flMean = m_Mean.GetFloat(); float flStdDev = m_StdDev.GetFloat(); float flVal = randomgaussian->RandomFloat( flMean, flStdDev ); float flMaxVal = m_flMaxVal.GetFloat(); float flMinVal = m_flMinVal.GetFloat(); if (flMinVal > flMaxVal) { float flTemp = flMinVal; flMinVal = flMaxVal; flMaxVal = flTemp; } // clamp if (flVal < flMinVal) flVal = flMinVal; else if ( flVal > flMaxVal ) flVal = flMaxVal; SetFloatResult( flVal ); if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
func Initialize() { var iTimeout,pWipf; SetGamma(RGB(15,15,15),RGB(118,118,118),RGB(215,215,215)); SetSkyParallax(0,15,17,0,0,0,0); //Handgemacht... ;) Meeresrauschen(170); Meeresrauschen(1100); Meeresrauschen(2060); Meeresrauschen(2900); Meeresrauschen(3800); Meeresrauschen(4800); Meeresrauschen(5700); Moewen(900); Moewen(2300); Moewen(3900); Moewen(5000); //Nebel platzieren for(var i;i<260;++i) CreateParticle("Fog",Random(LandscapeWidth()),Random(LandscapeHeight()*2/3),RandomX(3,9),0,RandomX(1000,1500)); //Wipfe platzieren while(pWipf=FindObject(WIPF,0,0,0,0,0,0,0,0,pWipf)) { iTimeout=0; while(Stuck(pWipf)||GetMaterial(GetX(pWipf),GetY(pWipf))!=Material("Tunnel")) { SetPosition(Random(LandscapeWidth()),RandomX(LandscapeHeight()*2/3,LandscapeHeight()),pWipf); if(iTimeout++ > 50000) { RemoveObject(pWipf); break; } } } ScriptGo(1); }
/// \brief /// Internal function inline MeshMaterial_t *GetSharedUVMaterial(int iMaterialIndex) const { MeshMaterial_t &mat = GetMaterial(iMaterialIndex); if (mat.m_iLightmapMergeID==-1) ///< never share return NULL; for (int i=0;i<iMaterialIndex;i++) { MeshMaterial_t &other(GetMaterial(i)); if (i==iMaterialIndex || other.m_iLightmapMergeID!=mat.m_iLightmapMergeID) continue; if ((other.m_iOverrideFlags&PRIMITIVEFLAG_RECEIVESHADOWS)==0) // this might be a submesh with collapsed UV - don't consider it continue; // also works for m_iOverrideFlags==-1 return &other; } return NULL; }
global func DrawIslands(iX, iY, iWidth, iHeight) { DrawMap(iX, iY, iWidth, iHeight, "map new { overlay { algo=bozo; turbulence=100; loosebounds=1; a=10; } & overlay { algo=rndchecker; turbulence=1000; a=1; mat=Earth; tex=Rough; overlay { algo=random; mat=Earth; tex=Smooth; }; overlay InEarth { grp=1; invert=1;overlay { algo=bozo; a=6; turbulence=1000; } & overlay { algo=rndchecker; a=2;turbulence=1000; mat=Rock; tex=Rough; };}; InEarth & overlay { mat=Gold; tex=Rough; }; InEarth & overlay { mat=Coal; tex=Swirl; };};overlay { algo=poly;point { x=0px; y=0px; };point { x=1px; y=0px; };point { x=1px; y=100%; };point { x=0px; y=100%; };}; overlay { algo=poly;point { x=99%; y=0px; };point { x=100%; y=0px; };point { x=100%; y=100%; };point { x=99%; y=100%; };}; overlay { algo=poly;point { x=0%; y=0px; };point { x=100%; y=0px; };point { x=100%; y=1%; };point { x=0%; y=1%; };};overlay { algo=poly;point { x=0%; y=99%; };point { x=100%; y=99%; };point { x=100%; y=100%; };point { x=0%; y=100%; };}; };"); for(var x=0; x < iWidth; x++) for(var y=0; y < iHeight; y++) DrawMaterialQuad (MaterialName(GetMaterial(x+iX, y+iY)), LandscapeWidth()-x-iX, y+iY, LandscapeWidth()-x-iX, y+iY+1, LandscapeWidth()-x-iX+1, y+iY+1, LandscapeWidth()-x-iX+1, y+iY); }
void MaterialEditor::SelectMaterial(int materialIndex) { Material *mat = GetMaterial(materialIndex); if(mat) { selectedMaterial = materialIndex; if(noMaterials->GetParent()) { RemoveControl(noMaterials); } PreparePropertiesForMaterialType(mat->type); } else { selectedMaterial = -1; if (materialProps->GetParent()) { RemoveControl(materialProps); } if(!noMaterials->GetParent()) { AddControl(noMaterials); } } }
global func BurnMarkCheck(int angle,int size, int iX, int iY) { var sin = Sin(angle,size); var cos = Cos(angle,size); var x = cos, y = sin, i=100; while(GetMaterial(iX+x,iY+y) == -1 || GetMaterialVal("Density","Material",GetMaterial(iX+x,iY+y)) != 0) { x = cos*i/100; y = sin*i/100; if(i <= 0) return 0; i-=10; } return size; }
//------------------------------------------------------------ //------------------------------------------------------------ void SpriteComponent::OnRenderSnapshot(RenderSnapshot& in_renderSnapshot) noexcept { Vector2 frameCenter; Vector2 frameSize; if(m_textureAtlas != nullptr && m_hashedTextureAtlasId > 0) { CalcFrameCentreAndSize(frameCenter, frameSize); } else if(mpMaterial != nullptr && mpMaterial->GetTexture() != nullptr) { auto texture = mpMaterial->GetTexture().get(); frameSize = m_sizePolicyDelegate(m_originalSize, Vector2((f32)texture->GetDimensions().x, (f32)texture->GetDimensions().y)); } UVs transformedUVs = m_uvs; if(m_flippedHorizontally == true && m_flippedVertically == true) { transformedUVs = UVs::FlipDiagonally(transformedUVs); } else if(m_flippedHorizontally == true) { transformedUVs = UVs::FlipHorizontally(transformedUVs); } else if(m_flippedVertically == true) { transformedUVs = UVs::FlipVertically(transformedUVs); } const auto& transform = GetEntity()->GetTransform(); auto renderDynamicMesh = SpriteMeshBuilder::Build(in_renderSnapshot.GetFrameAllocator(), Vector3(frameCenter, 0.0f), frameSize, transformedUVs, m_colour, m_originAlignment); auto boundingSphere = Sphere::Transform(renderDynamicMesh->GetBoundingSphere(), transform.GetWorldPosition(), transform.GetWorldScale()); in_renderSnapshot.AddRenderObject(RenderObject(GetMaterial()->GetRenderMaterialGroup(), renderDynamicMesh.get(), transform.GetWorldTransform(), boundingSphere, false, RenderLayer::k_standard)); in_renderSnapshot.AddRenderDynamicMesh(std::move(renderDynamicMesh)); }
void CWorldEditor::CreateBaseAxis() { auto sceneRoot = m_overlayViewport->GetSceneRoot(); static const CVector3 g_arrowScale(0.075f, 0.25f, 0.075f); { auto baseAxisNode = Palleon::CSceneNode::Create(); baseAxisNode->SetPosition(CVector3(289.2f, 5.00f, -563.f)); sceneRoot->AppendChild(baseAxisNode); { auto axisMesh = Palleon::CAxisMesh::Create(); axisMesh->SetScale(CVector3(1, 1, 1)); baseAxisNode->AppendChild(axisMesh); } //X arrow { auto coneMesh = Palleon::CConeMesh::Create(); coneMesh->SetPosition(CVector3(1, 0, 0)); coneMesh->SetRotation(CQuaternion(CVector3(0, 0, 1), M_PI / 2.f)); coneMesh->SetScale(g_arrowScale); coneMesh->GetMaterial()->SetColor(CColor(1, 0, 0, 1)); baseAxisNode->AppendChild(coneMesh); } //Y arrow { auto coneMesh = Palleon::CConeMesh::Create(); coneMesh->SetPosition(CVector3(0, 1, 0)); coneMesh->SetScale(g_arrowScale); coneMesh->GetMaterial()->SetColor(CColor(0, 1, 0, 1)); baseAxisNode->AppendChild(coneMesh); } //Z arrow { auto coneMesh = Palleon::CConeMesh::Create(); coneMesh->SetPosition(CVector3(0, 0, 1)); coneMesh->SetRotation(CQuaternion(CVector3(1, 0, 0), -M_PI / 2.f)); coneMesh->SetScale(g_arrowScale); coneMesh->GetMaterial()->SetColor(CColor(0, 0, 1, 1)); baseAxisNode->AppendChild(coneMesh); } } }
void CMaterialModifyProxy::OnBind( void *pEntity ) { // Get the modified material vars from the entity input IClientRenderable *pRend = (IClientRenderable *)pEntity; if ( pRend ) { C_BaseEntity *pBaseEntity = pRend->GetIClientUnknown()->GetBaseEntity(); if ( pBaseEntity ) { if( debug_materialmodifycontrol_client.GetBool() ) { // DevMsg( 1, "%s\n", pBaseEntity->GetDebugName() ); } int numChildren = 0; bool gotOne = false; for ( C_BaseEntity *pChild = pBaseEntity->FirstMoveChild(); pChild; pChild = pChild->NextMovePeer() ) { numChildren++; C_MaterialModifyControl *pControl = dynamic_cast<C_MaterialModifyControl*>( pChild ); if ( !pControl ) continue; if( debug_materialmodifycontrol_client.GetBool() ) { // DevMsg( 1, "pControl: 0x%p\n", pControl ); } switch( pControl->GetModifyMode() ) { case MATERIAL_MODIFY_MODE_NONE: break; case MATERIAL_MODIFY_MODE_SETVAR: gotOne = true; OnBindSetVar( pControl ); break; case MATERIAL_MODIFY_MODE_ANIM_SEQUENCE: OnBindAnimatedTexture( pControl ); break; case MATERIAL_MODIFY_MODE_FLOAT_LERP: OnBindFloatLerp( pControl ); break; default: Assert( 0 ); break; } } if( gotOne ) { // DevMsg( 1, "numChildren: %d\n", numChildren ); } } } if ( ToolsEnabled() ) { ToolFramework_RecordMaterialParams( GetMaterial() ); } }
Material* FBXScene::GetMaterialLinkedWithPolygon(FbxMesh* pFBXMesh, int nLayerIndex, int nPolygonIndex, int nPolygonVertexIndex, int nVertexIndex) { if( nLayerIndex < 0 || nLayerIndex > pFBXMesh->GetLayerCount() ) return NULL; FbxNode* pNode = pFBXMesh->GetNode(); if( !pNode ) return NULL; FbxLayerElementMaterial* pFBXMaterial = pFBXMesh->GetLayer(nLayerIndex)->GetMaterials(); if( pFBXMaterial ) { int nMappingIndex = GetMappingIndex( pFBXMaterial->GetMappingMode(), nPolygonIndex, 0, nVertexIndex ); if( nMappingIndex < 0 ) return NULL; FbxLayerElement::EReferenceMode referenceMode = pFBXMaterial->GetReferenceMode(); if( referenceMode == FbxLayerElement::EReferenceMode::eDirect ) { if( nMappingIndex < pNode->GetMaterialCount() ) { return GetMaterial(pNode->GetMaterial(nMappingIndex)); } } else if( referenceMode == FbxLayerElement::EReferenceMode::eIndexToDirect ) { const FbxLayerElementArrayTemplate<int>& pMaterialIndexArray = pFBXMaterial->GetIndexArray(); if( nMappingIndex < pMaterialIndexArray.GetCount() ) { int nIndex = pMaterialIndexArray.GetAt(nMappingIndex); if( nIndex < pNode->GetMaterialCount() ) { return GetMaterial(pNode->GetMaterial(nIndex)); } } } } return NULL; }
const ResourceRefList& StaticModel::GetMaterialsAttr() const { materialsAttr_.names_.Resize(batches_.Size()); for (unsigned i = 0; i < batches_.Size(); ++i) materialsAttr_.names_[i] = GetResourceName(GetMaterial(i)); return materialsAttr_; }
//----------------------------------------------------------------------------- // Purpose: // Input : pDC - // dstRect - // detectErrors - //----------------------------------------------------------------------------- void CMaterial::DrawBrowserIcons( CDC *pDC, RECT& dstRect, bool detectErrors ) { static CMaterial* pTranslucentIcon = 0; static CMaterial* pOpaqueIcon = 0; static CMaterial* pSelfIllumIcon = 0; static CMaterial* pBaseAlphaEnvMapMaskIcon = 0; static CMaterial* pErrorIcon = 0; if (!pTranslucentIcon) { pTranslucentIcon = CreateMaterial("editor/translucenticon", true); pOpaqueIcon = CreateMaterial("editor/opaqueicon", true); pSelfIllumIcon = CreateMaterial("editor/selfillumicon", true); pBaseAlphaEnvMapMaskIcon = CreateMaterial("editor/basealphaenvmapmaskicon", true); pErrorIcon = CreateMaterial("editor/erroricon", true); Assert( pTranslucentIcon && pOpaqueIcon && pSelfIllumIcon && pBaseAlphaEnvMapMaskIcon && pErrorIcon ); } bool error = false; IMaterial* pMaterial = GetMaterial(); if ( pMaterial->GetMaterialVarFlag( MATERIAL_VAR_TRANSLUCENT ) ) { DrawIcon( pDC, pTranslucentIcon, dstRect ); if (detectErrors) { error = error || !m_TranslucentBaseTexture; } } else { DrawIcon( pDC, pOpaqueIcon, dstRect ); } if ( pMaterial->GetMaterialVarFlag( MATERIAL_VAR_SELFILLUM )) { DrawIcon( pDC, pSelfIllumIcon, dstRect ); if (detectErrors) { error = error || !m_TranslucentBaseTexture; } } if ( pMaterial->GetMaterialVarFlag( MATERIAL_VAR_BASEALPHAENVMAPMASK )) { DrawIcon( pDC, pBaseAlphaEnvMapMaskIcon, dstRect ); if (detectErrors) { error = error || !m_TranslucentBaseTexture; } } if (error) { DrawIcon( pDC, pErrorIcon, dstRect ); } }
void KVIonRangeTable::SetTemperatureAndPressure(const Char_t*material, Double_t temperature, Double_t pressure) { // Set temperature (in degrees celsius) and pressure (in torr) for a given // material. This has no effect except for gaseous materials, for which T & P // determine the density (in g/cm**3). KVIonRangeTableMaterial* M = GetMaterial(material); if (M) M->SetTemperatureAndPressure(temperature, pressure); }