spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

{
        List<unsigned long> KnownColors;

        size = ParzellenKey->getSize();
        s32 Pcount(size.Height * size.Width);

        unsigned long CToAdd;
        CArray = new unsigned long[Pcount];

        //die Anzahl der Farben feststellen

        {
            char* lockedrect = (char*)ParzellenKey->lock(); 
            switch(ParzellenKey->getColorFormat())
            {
            case ECF_A8R8G8B8:
                {
                    memcpy(CArray, lockedrect, 4 * Pcount);

                    CToAdd = 0xFF000000;
                    KnownColors.push_back(CToAdd);
                    for(s32 counter = 0; counter < Pcount; counter++)
                    {
                        if(!KnownColors.GetElementByContent(CArray[counter]))
                            KnownColors.push_back(CArray[counter]);
                    }
                }break;

            default:
                return;
            }
            ParzellenKey->unlock();
        }
        NumSelectMaps = KnownColors.getSize();

        //Stimmt die Anzahl der Parzellen mit der Anzahl der Farben überein?

        if(NumSelectMaps - 1 != planet->getParzellenCount())
        {
            std::cout<<"Die Anzahl der Parzellen auf der Colormap entspricht nicht der angegeben Anzahl des Planeten. Betroffene Textur: "<< ParzellenKey->getName().c_str() << std::endl;
            return;//error

        }

        //Die dazu gehörige Parzelle und den Besitzer feststellen

        PFrames = new SelectMap[NumSelectMaps];

        List<unsigned long>::Iterator iter  = KnownColors.begin();
        List<Parzelle*>::Iterator temp      = planet->GetParzelle();


        PFrames[0].SelectTexture = smgr->getVideoDriver()->addTexture(size, "", ECF_A8R8G8B8);
        PFrames[0].ColorKey = *iter;
        PFrames[0].parzelle = NULL;
        PFrames[0].OldOwner = NULL;
        PFrames[0].ReplaceColor[0] = 0xFF555555;
        PFrames[0].ReplaceColor[1] = 0xFF000000;

        iter++;
        for(short counter = 1; counter < NumSelectMaps; iter++, counter++, temp++)
        {   
            if(temp == planet->GetParzelleEnd())
                return; //EDIT: Fehler es müssen gleichviele vorhanden sein



            PFrames[counter].SelectTexture = smgr->getVideoDriver()->addTexture(size, "", ECF_A8R8G8B8);
            PFrames[counter].ColorKey = *iter;
            PFrames[counter].parzelle = (*temp);
            PFrames[counter].OldOwner = (*temp)->GetOwner();

            if(!PFrames[counter].OldOwner)  //Kein Besitzer

            {
                PFrames[counter].ReplaceColor[0] = 0xFFFFFFFF;
                PFrames[counter].ReplaceColor[1] = 0xFF999999;
            }
            else if(FVerwaltung::GetFiregalaxy()->Player == PFrames[counter].OldOwner)  //Der Spieler ist der Besitzer

            {
                PFrames[counter].ReplaceColor[0] = 0xFF00FF00;
                PFrames[counter].ReplaceColor[1] = 0xFF009900;
            }
            else if(FVerwaltung::GetFiregalaxy()->Player->GetFraction() == PFrames[counter].OldOwner->GetFraction()) // Der Besitzer ist in der selben Fraktion wie der Spieler

            {
                PFrames[counter].ReplaceColor[0] = 0xFF0000FF;
                PFrames[counter].ReplaceColor[1] = 0xFF000099;
            }
            else    //Der Spieler ist mit dem anderen Verfeindet

            {
                PFrames[counter].ReplaceColor[0] = 0xFFFF0000;
                PFrames[counter].ReplaceColor[1] = 0xFF990000;
            }
        }

        //Auf Basis der oben gesammelten Informationen, werden nun die einzelnen Parzellen auf der Textur eingefärbt

        for(short counter = 0; counter < NumSelectMaps; counter++)
        {   
            //Die einzelnen Textur einfärben

            char* lockedtext = (char*)PFrames[counter].SelectTexture->lock();

            for(s32 counter2 = 0; counter2 < Pcount; counter2++)
            {
                if(CArray[counter2] == 0xFF000000)
                    CToAdd = 0xFF000000;
                else if(CArray[counter2] == PFrames[counter].ColorKey)
                    CToAdd = PFrames[counter].ReplaceColor[0];
                else
                    for(short counter1 = 1; counter1 < NumSelectMaps; counter1++)
                    {
                        if(CArray[counter2] == PFrames[counter1].ColorKey)
                        {
                            CToAdd = PFrames[counter1].ReplaceColor[1];
                            break;
                        }
                    }

                    memcpy(lockedtext + counter2 * 4, &CToAdd, 4);
            }
            PFrames[counter].SelectTexture->unlock();
            PFrames[counter].SelectTexture->regenerateMipMapLevels(); 
        }
    }

C-/C++-Quelltext

    //Farbe des selektierten Sektor rausfinden

    DWORD SelectedColor;
    {
        vector3df outpoint;
        triangle3df outtri, tri;

        ISceneCollisionManager* Collm = smgr->getSceneCollisionManager();
        line3d<f32> line = Collm->getRayFromScreenCoordinates(Main->GetCursorPos(), Kamera);

        if(!Collm->getCollisionPoint(line, PlanetModell->getTriangleSelector(), outpoint, outtri))
            return;

        vector2df TextPos(0,0);
        PlanetModell->updateAbsolutePosition();

        //Die 3 zu dem Dreieck gehörenden Vertices sammeln bzw. deren Texturkoords

        for(s32 counter = 0; counter < numVertices; counter++)
        {
            vector3df tempvec = Vertices[counter];
            PlanetModell->getAbsoluteTransformation().transformVect(tempvec);

            if(tempvec / 100.0f  == outtri.pointA / 100.0f || tempvec / 100.0f  == outtri.pointB / 100.0f || tempvec / 100.0f  == outtri.pointC / 100.0f)
                TextPos += Textcoord[counter];
        }
        TextPos = TextPos / 3.0f;
    
        s32 texel = (s32)(((s32)(TextPos.Y * size.Height)) * size.Width + TextPos.X * size.Width);
        SelectedColor = CArray[texel];
    }
    //Nun die aktuell ausgewählte Parzelle feststellen und die entsprechende Textur reinhauen

    {
        SelectedSector = 0;
        for(short counter = 1; counter < NumSelectMaps; counter++)
        {
            if(PFrames[counter].ColorKey == SelectedColor)
            {
                SelectedSector = counter;
                break;
            }
        }
        PlanetModell->setMaterialTexture(1, PFrames[SelectedSector].SelectTexture);
    }