# 3D renderer

## cool thingy

### by kasicakim

1st we need a layout of pixles, all pixles that are on, pixle names, campositionm screenposition and FOV

``````local X = 70
local Y = 70

local pixles = {}
local pixlenames = {}
local whitepixls = {}

local CamPosition = Vector3.zero
local ScreenPosition = 5
--screen position is 5 bc thats its z position, it doesnt need x or y bc it goes infinitevly far into those directions
local FOV = 80

for x=1, X do
for y=1, Y do
local pixle = Instance.new("Part")
pixle.Size = Vector3.new(1/10, 1/10)
pixle.Color = Color3.new()
pixle.Position = Vector3.new(x/10, y/10, 100)
pixle.Name = "X"..tostring(x-X/2).."Y"..tostring(y-Y/2)
pixle.Anchored = true
pixle.Parent = workspace
table.insert(pixles, pixle)
table.insert(pixlenames, pixle.Name)
end
wait()
end

``````

Vertexes are just positions used for 3d space

Edges are tables that have 2 values that contain the place in the tbl where a vertex is

Object has its vertexes, edges and its color, the vertex table of the object are just positions in the table Vertexes where a vertex is, same of edges.

``````local Vertexes = {}
local Edges = {}
local Objects = {}

end

end

table.insert(Objects, {verts, edgs, color})
end

``````

We now have our layout done, next thing we need to do is calculate the position of the pixle that needs to be lighten up. For this we will use a formula (idk how to explain it :p).

``````local function GetProjected(pos, Z)
return math.round((pos*FOV)/(FOV+Z))
end

local function CalculatePosition(v)
local x = GetProjected(v.X, v.Z)
local y = GetProjected(v.Y, v.Z)

return Vector2.new(x, y)
end

``````

Now for the edges we will use a simple DrawLine function that takes 2 Vector2s on the screen and a color:

``````local function LightPixle(pos, color)
pcall(function()
FindPixle(pos).Color = color
table.insert(whitepixls, pos)
end)
end

local function LightPixleWithProjected(pos, color)
local v = CalculatePosition(pos)
LightPixle(v, color)
end

local function DrawLine(pos1, pos2, color)
local poss = {}

local dy = math.abs(pos1.Y - pos2.Y)
local dx = math.abs(pos1.X - pos2.X)

if dy >= dx then
local currentY = pos1.Y
local ddy = 0
if pos1.Y > pos2.Y then
ddy = -1
else
ddy = 1
end
while currentY ~= pos2.Y do
local currentX = math.round(pos2.X + ((pos1.X - pos2.X) / (pos1.Y - pos2.Y)) * (currentY - pos2.Y))
table.insert(poss, Vector2.new(currentX, currentY))
currentY = currentY + ddy
end
else
local currentX = pos1.X
local ddx = 0
if pos1.X > pos2.X then
ddx = -1
else
ddx = 1
end
while currentX ~= pos2.X do
local currentY = math.round(pos2.Y + ((pos1.Y - pos2.Y) / (pos1.X - pos2.X)) * (currentX - pos2.X))
table.insert(poss, Vector2.new(currentX, currentY))
currentX = currentX + ddx
end
end
for i=1, #poss do
LightPixle(poss[i], color)
end
end

``````

Now we just need to project the object using these functions:

``````local function ProjectObject(object)
local verts = object[1]
local edges = object[2]
local color = object[3]

for x=1, #verts do
local vertex = Vertexes[verts[x]]
LightPixleWithProjected(vertex[1], color)
end
for x=1, #edges do
local edge = Edges[edges[x]]
local e1 = edge[1]
local e2 = edge[2]
local pos1 = CalculatePosition(Vertexes[e1][1])
local pos2 = CalculatePosition(Vertexes[e2][1])
DrawLine(pos1, pos2, color)
end
end

``````

You can have some fun and add rotation (rly hard to explain go onto a wiki about matrix rotation to find out more).

``````local function ClearPixles()
for x=1, #whitepixls do
LightPixle(whitepixls[x], Color3.new())
end
table.clear(whitepixls)
end

local function RotateObjX(obj, r, poss)
for x=1, #obj[1] do
local pos = Vertexes[obj[1][x]][1]-poss
Vertexes[obj[1][x]][1] = newpos
end
end

local function RotateObjY(obj, r, poss)
local s = poss
for x=1, #obj[1] do
local pos = Vertexes[obj[1][x]][1]-poss
Vertexes[obj[1][x]][1] = newpos
end
end

local function RotateObjZ(obj, r, poss)
for x=1, #obj[1] do
local pos = Vertexes[obj[1][x]][1]-poss
Vertexes[obj[1][x]][1] = newpos
end
end
``````

Lets make a plane and project it:

``````AddVertex(Vector3.new(10, 10, 40), 1)

AddObject({1, 2, 3, 4}, {1, 2, 3, 4, 5}, Color3.new(1, 0, 0))

ProjectObject(Objects[1])
``````

You can also add rotation with rotate functions:

``````while wait() do
ProjectObject(Objects[1])
wait(.05)
ClearPixles()
RotateObjY(Objects[1], 5, Vector3.new(0, 0, 40))
wait()
RotateObjX(Objects[1], 5, Vector3.new(0, 0, 40))
end
``````

Go and have fun or smth, this script isnt rly good for a lot of objects bc roblox is slow :p. It could be faster if you dont use pixles and add parts into the workspace. go make smth with this.