Creating Wall with 2 points,

Vacation time: I will be on vacation from July 5th to July 15th, please don't expect any replies during that period. Thank you for your patience.

RandhirP

Hello @Anthony

We're trying to create a wall within an existing room that starts from a point on one wall and ends somewhere before reaching the opposite wall. To achieve this, we made the following changes

In RoomController → Rebuild() method:

We added logic to detect when there are only two control points, and in that case, we call a new method GenerateSingleWall(start, end) from the ProceduralRoom class. This method handles the creation of a standalone wall segment between those two points.

override protected void Rebuild(bool sendRepositionOpeningsEvent = false)
{
if (lastRebuild > Time.time - delayBetweenRebuilds)
{
queuedRebuild = true;
if (sendRepositionOpeningsEvent)
queuedSendRepositionOpeningsEvent = true;
return;
}

        if (sendRepositionOpeningsEvent)
        {
            //print("call OnRequestRepositionOpenings");
            GameEditorEvents.OnRequestRepositionOpenings?.Invoke();
        }

        lastRebuild = Time.time;
        queuedRebuild = false;
        queuedSendRepositionOpeningsEvent = false;


        //print("RebuildMesh sendRepositionOpeningsEvent:" + sendRepositionOpeningsEvent + " roomColor:" + roomCOlor);
        List<Vector3> worldPosList = cpc.GetPointsWorldPositionList();

        if (proceduralSpace == null)
            proceduralSpace = GetComponent<ProceduralRoom>();

        if (worldPosList.Count == 2)
        {
            proceduralRoom.GenerateSingleWall(worldPosList[0], worldPosList[1]);
            return;
        }
        if (worldPosList.Count < 3 || MathUtils.PointsAreInLine(worldPosList))
        {
            proceduralSpace.GenerateEmpty();
            return;
        }
        //print("Room Rebuild");

        // Getting all windows
        List<ProceduralRoom.GenericOpening> openings = new List<ProceduralRoom.GenericOpening>();
        List<Vector3> pointList = null;
        UIBaseItem[] items = GameObject.FindObjectsOfType<UIBaseItem>();

        for (int i = 0; i < items.Length; i++)
        {
            ProceduralRoom.GenericOpening.OpeningType oType = ProceduralRoom.GenericOpening.OpeningType.Opening;
            Enum.TryParse<ProceduralRoom.GenericOpening.OpeningType>(items[i].sequencingItemType.ToString(), out oType);

            if (items[i].sequencingItemType == DataModel.FloorMapItemType.Door ||
               items[i].sequencingItemType == DataModel.FloorMapItemType.Window ||
               items[i].sequencingItemType == DataModel.FloorMapItemType.Opening)
            {
                pointList = items[i].cpc.GetPointsWorldPositionList();
                for (int j = 0; j < pointList.Count; j++)
                {
                    openings.Add(new ProceduralRoom.GenericOpening(oType, pointList[j], items[i]));
                }

            }
        }

        proceduralSpace.Openings = openings;
        proceduralSpace.SpaceVertexColor = DrawingColor;
        proceduralSpace.Generate(worldPosList);

        GameEditorEvents.OnRequestRebuildBuilding?.Invoke();
    }

In ProceduralRoom
We added the GenerateSingleWall(Vector3 start, Vector3 end) function to build a mesh for just one wall between the two given points.

public void GenerateSingleWall(Vector3 start, Vector3 end)
{

        float height = 2.5f; 
        float thickness = 0.1f;
        Vector3 dir = (end - start).normalized;
        Vector3 normal = Vector3.Cross(dir, Vector3.up).normalized;

        Vector3 p1 = start + normal * thickness;
        Vector3 p2 = start - normal * thickness;
        Vector3 p3 = end + normal * thickness;
        Vector3 p4 = end - normal * thickness;

        Mesh wallMesh = new Mesh();
        Vector3[] vertices = new Vector3[]
        {
            p1, p2, p3, p4,
            p1 + Vector3.up * height,
            p2 + Vector3.up * height,
            p3 + Vector3.up * height,
            p4 + Vector3.up * height
        };

        int[] triangles = new int[]
        {
            // Front face
            0, 1, 4,
            1, 5, 4,
            2, 3, 6,
            3, 7, 6,
            // Top face
            4, 5, 6,
            5, 7, 6,
            // Bottom face
            0, 2, 1,
            1, 2, 3,
            // Left face
            0, 4, 2,
            2, 4, 6,
            // Right face
            1, 3, 5,
            3, 7, 5
        };

        wallMesh.vertices = vertices;
        wallMesh.triangles = triangles;
        wallMesh.RecalculateNormals();

        walls.mesh = wallMesh;
        //walls.mesh.material = wallMaterial; 
    }

With these changes, the wall appears correctly in the FloorMapEditor scene (example link: https://postimg.cc/gallery/pP8k4r7 ).

However, when we save the floor plan and open it in the HomeDesigner scene, the wall does not appear. We suspect the issue is with the Interior Serializer – it might not be handling rooms with only two control points properly.

Could you please help us figure out how to resolve this?
Is there a specific approach or update we should consider to make this work across both scenes?

Thanks in advance!

Anthony

RandhirP make sure you check all the places where the code stops if there is less than 3 points (RoomController::BuildRoom())

Image description

Otherwise I think it's good to be able to add single walls, good job, let me know how it goes! I would like to add this feature in the plugin.

RandhirP

Hello I have checked all the positions wherever the code stops on 2 points or less, I found it at 2 places

FloorController->BuildRoom()
RoomController -> Rebuild()

Added this code snippet before the checking for 3 points
// Handle 2-point case for single wall if (worldPosList.Count == 2) { proceduralRoom.InitializeSingleWall(worldPosList[0], worldPosList[1], AppController.Instance.wallsHeight); return; }
We have also modified the Generate Single wall function which works similar to the wallGeneration which you have implemented using functions like GetOpeningsBetweenPoints and CreateWallWithOpening,
the functions snippet is are

` public void InitializeSingleWall(Vector3 start, Vector3 end, float height)
{
innerRoomPoints = new List<Vector3> { start, end };
normalRoomPoints = new List<Vector3> { start, end };
openings = new List<GenericOpening>();

 GenerateSingleWall(start, end, height);

 floor.mesh = null;
 ceiling.mesh = null;

}

public void GenerateSingleWall(Vector3 start, Vector3 end, float height = 3f)
{
float thickness = AppController.Instance.exteriorWallThickness;

Vector3 dir = (end - start).normalized;
Vector3 offset = Vector3.Cross(dir, Vector3.up).normalized * (thickness * 0.5f);

Vector3 p0Inner = start - offset;
Vector3 p1Inner = end - offset;
Vector3 p0Outer = start + offset;
Vector3 p1Outer = end + offset;

// Build outer wall mesh
var outerOpenings = GetOpeningsBetweenPoints(openings, p0Inner, p1Inner, p0Outer, p1Outer);
MeshDraft outerWall = CreateWallWithOpening(p0Outer, p1Outer, height, outerOpenings, false, thickness);

// Build inner wall mesh (flip normals inward)
var innerOpenings = GetOpeningsBetweenPoints(openings, p0Outer, p1Outer, p0Inner, p1Inner);
MeshDraft innerWall = CreateWallWithOpening(p0Inner, p1Inner, height, innerOpenings, true, thickness);

// Combine them into one mesh draft
MeshDraft md = new MeshDraft { name = "SingleWallSegment" };
md.Add(outerWall);
md.Add(innerWall);
md.Paint(SpaceVertexColor);

// Assign to mesh filter & collider
InitSeparateWallsList(1);
MeshFilter mf = GetOrCreateSeparateWallMeshFilter(0);
Mesh mesh = md.ToMesh();
mf.mesh = mesh;

// Add or update collider
MeshCollider mc = mf.GetComponent<MeshCollider>();
if (mc == null)
    mc = mf.gameObject.AddComponent<MeshCollider>();
mc.sharedMesh = mesh;

}
`
After implementing this, we're able to successfully create the inner wall, which is now also visible and editable in the Interior Designer. However, there are two major issues:

The inner wall appears where the outer wall should be.

The outer wall is placed at Vector3.zero, and its shape is completely distorted — as seen in the Interior Designer screenshot.

In the screenshot, there's a yellowish door-like structure in the center of the room extending across, which might be the malformed wall.

Could you help us understand why this is happening? Also, we’d appreciate some clarification on how wall creation is handled in the plugin:

You seem to distinguish between interior and exterior walls, where interior walls are created as separate mesh objects, and exterior walls are merged into a single mesh.

We're following the same approach, and while interior walls are appearing (though misplaced), the exterior walls are not rendering correctly at all — they’re off-position and malformed.

Here’s the screenshot for reference: [https://postimg.cc/gallery/xnGpx2L](https://)

Thanks in advance for your help!

Anthony

RandhirP at first look your code seem to be the right way to go. It's hard to see the issue, given that I haven't been working on this for a long time, but I can try it in the next couple of days.

To answer your questions: the inner walls are cut to allow the user to paint them separately in Home designer. Whereas the exterior wall doesn't need to be cut, so it's kept as a single mesh.
In your case your want to avoid the exterior wall to be drawn and just keep it as 2 interior walls.

I will keep you posted once I have the chance to try it out on my side.

Anthony

I changed the points in your code and now the walls are drawn at the right direction:

        Vector3 p0Inner = start + offset;
        Vector3 p1Inner = end + offset;
        Vector3 p0Outer = start - offset;
        Vector3 p1Outer = end - offset;

Anthony

Image description

Anthony

I also added code to draw the contours, just after the line "md.Paint(SpaceVertexColor);"


            //Create the contours
            List<Vector2> clip = new List<Vector2>();

            clip.Add(new Vector2(0, 0));
            clip.Add(new Vector2(0, height));
            clip.Add(new Vector2(vec.magnitude, height));
            clip.Add(new Vector2(vec.magnitude, 0));
            
            MeshDraft windowFrame = MathUtils.Extrude(clip, Vector3.back, thickness, false);
            windowFrame.Rotate(Quaternion.FromToRotation(Vector3.right, vec.normalized));
            windowFrame.Move(p0Inner);
            md.Add(windowFrame);

Image description

RandhirP

Hello @Anthony#1,

Thank you for your patience and for helping us debug this issue.

I've applied the changes you suggested, but unfortunately, we're still not seeing the new behavior take effect. Specifically, the exterior walls are still not generating correctly or appearing in the right position. You may notice this in the images I shared in our previous conversation as well.

In the code snippet you provided for drawing contours, we assume the vector Vec = end - start, which we applied. However, in our case, the exterior walls are not being generated at all—only duplicate colliders for doors and windows are created, and their meshes are missing (as you can see in the attached screenshot).

Currently, I’ve attached the updated code with your changes applied:

`
public void InitializeSingleWall(Vector3 start, Vector3 end, float height)
{
innerRoomPoints = new List<Vector3> { start, end };
normalRoomPoints = new List<Vector3> { start, end };
openings = new List<GenericOpening>();

GenerateSingleWall(start, end, height);

floor.mesh = null;
ceiling.mesh = null;

}

public void GenerateSingleWall(Vector3 start, Vector3 end, float height = 3f)
{
float thickness = AppController.Instance.exteriorWallThickness;

Vector3 dir = (end - start).normalized;
Vector3 offset = Vector3.Cross(dir, Vector3.up).normalized * (thickness * 0.5f);

Vector3 p0Inner = start + offset;
Vector3 p1Inner = end + offset;
Vector3 p0Outer = start - offset;
Vector3 p1Outer = end - offset;

Vector3 vec = end - start;

// Build outer wall mesh
var outerOpenings = GetOpeningsBetweenPoints(openings, p0Inner, p1Inner, p0Outer, p1Outer);
MeshDraft outerWall = CreateWallWithOpening(p0Outer, p1Outer, height, outerOpenings, false, thickness);

// Build inner wall mesh (flip normals inward)
var innerOpenings = GetOpeningsBetweenPoints(openings, p0Outer, p1Outer, p0Inner, p1Inner);
MeshDraft innerWall = CreateWallWithOpening(p0Inner, p1Inner, height, innerOpenings, true, thickness);

// Combine into one mesh draft
MeshDraft md = new MeshDraft { name = "SingleWallSegment" };
md.Add(outerWall);
md.Add(innerWall);
md.Paint(SpaceVertexColor);

List<Vector2> clip = new List<Vector2>
{
    new Vector2(0, 0),
    new Vector2(0, height),
    new Vector2(vec.magnitude, height),
    new Vector2(vec.magnitude, 0)
};

MeshDraft windowFrame = MathUtils.Extrude(clip, Vector3.back, thickness, false);
windowFrame.Rotate(Quaternion.FromToRotation(Vector3.right, vec.normalized));
windowFrame.Move(p0Inner);
md.Add(windowFrame);

// Assign to mesh filter & collider
InitSeparateWallsList(1);
MeshFilter mf = GetOrCreateSeparateWallMeshFilter(0);
Mesh mesh = md.ToMesh();
mf.mesh = mesh;

// Add or update collider
MeshCollider mc = mf.GetComponent<MeshCollider>();
if (mc == null)
    mc = mf.gameObject.AddComponent<MeshCollider>();
mc.sharedMesh = mesh;

}

MeshDraft windowFrame = MathUtils.Extrude(clip, Vector3.back, thickness, false);
windowFrame.Rotate(Quaternion.FromToRotation(Vector3.right, vec.normalized));
windowFrame.Move(p0Inner);
md.Add(windowFrame);

// Assign to mesh filter & collider
InitSeparateWallsList(1);
MeshFilter mf = GetOrCreateSeparateWallMeshFilter(0);
Mesh mesh = md.ToMesh();
mf.mesh = mesh;

// Add or update collider
MeshCollider mc = mf.GetComponent<MeshCollider>();
if (mc == null)
    mc = mf.gameObject.AddComponent<MeshCollider>();
mc.sharedMesh = mesh;

}
`
Additionally, we’ve noticed that the package creates two types of walls:

One set is a child of ProceduralBuilding, which appears to be the combined mesh for all walls in the scene.

The second set includes individual wall segments, which are children of the Walls(-go) object under the RoomControllerPrefab.

From what I understand, you're generating two quads for each wall—possibly for rendering them from different angles—and you also add a mesh for the wall's thickness (which may be what creates the exterior visual). Please correct me if I’ve misunderstood this.

Could you please provide some insight into:

Why these two wall types are separated?

How this affects rendering or physics (e.g., colliders)?

Whether this design impacts mesh generation for exterior walls?

Any clarification would help us better align with your intended architecture and resolve this issue effectively.

Thanks again for your support.

Link To the Image

Anthony

As I explained in my previous post that you may have missed:
the inner walls are cut to allow the user to paint them separately in Home designer. Whereas the exterior wall is a single material and doesn't need to be cut, so it's kept as a single mesh.
In your case your want to avoid the exterior wall to be drawn and just keep it as 2 interior walls.

The exterior walls are only drawn around rooms (more than 3 points). If you draw a single wall, as this is not a room, there is no way for the code to know how to draw the exterior mesh on it. The only thing you can do like in my example is to draw the single walls inside a room, with the 2 faces being interior walls.

If you want to draw exterior single walls, this is not possible at the moment and would require more custom code.

I hope that helps

RandhirP

Hello Anthony

Thank you for your patience and helping us with this issue,

We have applied the changes you suggested, but now we cannot figure out, why can't we generate opening with this, when we add opening ( or door or window ), they are placed at correct position, but the wall do not generate opening, can you help us with this issue?

Anthony

RandhirP the openings are not generated because the openings variable is empty.

Edit your code like this:

 public void InitializeSingleWall(Vector3 start, Vector3 end, float height)
 {
     if(openings == null)
         openings = new List<GenericOpening>();

and in RoomController, move the 2 if blocks, after you passed the openings:

proceduralSpace.Openings = openings;
proceduralSpace.SpaceVertexColor = DrawingColor;


if (worldPosList.Count == 2)
{
    proceduralRoom.InitializeSingleWall(worldPosList[0], worldPosList[1],
        AppController.Instance.wallsHeight);
    return;
}
// If there are not enough points or they are collinear, generate an empty room
if (worldPosList.Count < 3 || MathUtils.PointsAreInLine(worldPosList))
{
    proceduralSpace.GenerateEmpty();
    return;
}