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