the camera allows you to get a picture from the world and display it on the screen (or process it inside the program)
please note that rendering methods may receive not the real display, but the "virtual" one you created. 3 methods should be implemented in the virtual screen: getWidth, getHeight, drawPixel
please note that when transmitting a virtual display, the camera returns colors in string format, which slows down its operation. this is done for compatibility with old software. however, if your code is ready to accept objects with the Color type, then add the "noCameraEncode" field to the table of your virtual display equal to true. The vdisplay library does this by default. in cases where CustomDraw is used with this flag, your virtual display will receive the actual value from the renderer
this can be used, for example, to save an image to disk (methods for this are already implemented in the image library)
however, if you are just going to display the image on the displays, then provide the camera with a REAL DISPLAY. since transferring the virtual display disables very important camera optimizations
if you want to use the same camera from two different locations, use the camera.fork function to create a new instance with a separate counter and viewport. you can also use camera.fork with the value true to create a copy of all the parameters (fov, step, rotation, etc.)
to connect the camera via the antenna, use cameraTunnel component

advanced render settings (default / false):

                    {
    lampLighting = true,
    shadows = true,
    smoothingTerrain = true,
    simpleShadows = true,
    sun = true, --is the solar disk being rendered
    fog = true,
    reduceAccuracy = true, --allows you to use fewer display effects in fog and simpleShadows, which increases performance in some cases

    constDayLightValue = nil, --you can make a constant time of day
    shadowMultiplier = 0.6,
    sunPercentage = 0.003, --this value is the percentage of the sun from the size of the sky
    simpleShadowMin = 0.3, --the minimum brightness of an object that a simple shadow can give
    simpleShadowMax = 1, --the maximum brightness of an object that a simple shadow can give

    customWaterColor = nil,
    customChemicalColor = nil,
    customOilColor = nil,

    constColor = nil, --allows you to make all objects in one color
    constSkyColor = nil, --by default, it depends on the time of day
    customSunColor = nil, --you can change the color of the sun
    constShapeColor = nil,
    customLiftColor = nil,
    constTerrainColor = nil, --you can make the whole terrain one color, even blue
    constCharacterColor = nil,
    constJointColor = nil,
    constHarvestableColor = nil, --allows all Harvestables to be the same color, instead of their real color
    constAssetsColor = nil, --you can set the constant color of assets so that it is always 1 and is not determined by the material

    customTerrainColor_dirt = nil,
    customTerrainColor_grass = nil,
    customTerrainColor_sand = nil,
    customTerrainColor_stone = nil,
}
                

advanced render settings (true / fastmode):

                    {
    lampLighting = false,
    shadows = false,
    smoothingTerrain = false,
    simpleShadows = true,
    sun = true, --is the solar disk being rendered
    fog = true,
    reduceAccuracy = true, --allows you to use fewer display effects in fog and simpleShadows, which increases performance in some cases

    constDayLightValue = nil, --you can make a constant time of day
    shadowMultiplier = 0.6,
    sunPercentage = 0.003, --this value is the percentage of the sun from the size of the sky
    simpleShadowMin = 0.3, --the minimum brightness of an object that a simple shadow can give
    simpleShadowMax = 1, --the maximum brightness of an object that a simple shadow can give

    customWaterColor = nil,
    customChemicalColor = nil,
    customOilColor = nil,

    constColor = nil, --allows you to make all objects in one color
    constSkyColor = nil, --by default, it depends on the time of day
    customSunColor = nil, --you can change the color of the sun
    constShapeColor = nil,
    customLiftColor = nil,
    constTerrainColor = nil, --you can make the whole terrain one color, even blue
    constCharacterColor = nil,
    constJointColor = nil,
    constHarvestableColor = nil, --allows all Harvestables to be the same color, instead of their real color
    constAssetsColor = nil, --you can set the constant color of assets so that it is always 1 and is not determined by the material

    customTerrainColor_dirt = nil,
    customTerrainColor_grass = nil,
    customTerrainColor_sand = nil,
    customTerrainColor_stone = nil,
}
                




methods:

• camera.fork(cloneSettings:boolean):camera - creates a clone of the camera with a separate counter and viewport for use from two locations. you can pass true to clone settings (fov, step, rotation, etc.)
• camera.drawAdvanced(display, settings:table|boolean|nil) - it gives the best picture for the camera at the moment. supports the sun, the change of day and night, shadows, lamp lighting, the color of the earth
• camera.drawColorWithDepth(display, noCollideColor, terrainColor, unitsColor) - a fairly simple display mode
• camera.drawColor(display, noCollideColor, terrainColor, unitsColor) - the fastest display mode. it gives a picture of not the best quality
• camera.drawDepth(display, baseColor, noCollideColor, unitsColor) - It doesn't give a very pretty picture
• camera.drawCustom(display, drawer, ...) - allows you to make your own display mode. it is suitable for creating various kinds of thermal imagers, etc. however, this mode is very laggy (especially in multiplayer)
• camera.deepDrawCustom(display, drawer, maxIntersections, ...) - it works the same way as camera.drawCustom, but it sees through objects, giving out all intersections (unrestricted camera only)
• camera.setStep(number) - sets the number of pixels that the camera will render per tick (maximum 4096)
• camera.getStep():number - returns the number of pixels that the camera will render in tick
• camera.setDistance(number) - sets the drawing distance for the camera in meters (maximum 2048)
• camera.getDistance():number - returns the camera's drawing distance
• camera.setFov(number) - sets the fov for the camera by X and by Y (maximum 165, minimum 1)
• camera.setNonSquareFov(number, number) - sets a non-square FOV for the camera, ideal for non-square displays (maximum 165, minimum 1)
• camera.getFovX():number - returns the camera's fov by X
• camera.getFovY():number - returns the camera's fov by Y
• camera.getFov():number - returns the camera's fov. if the fov is not square it returns the maximum value
• camera.getNextPixel():number - returns the current value of the counter
• camera.setNextPixel(number) - sets the value of the pixel counter
• camera.resetCounter() - resets the camera pixel counter (starts rendering the screen first)
• camera.rawRay(xAngle:number, yAngle:number, distance:number):table - ray shoots from the camera and gives out a table
  

  {
      color = smcolor,
      distance = distance,
      fraction = (distance / maxdist),
      deepDistance = (deep methods only) works almost the same as "distance", but the values are the values of the entire ray, not just this intersection segment. exists only at the last intersection,
      deepFraction = (deep methods only) works almost the same as "fraction", but the values are the values of the entire ray, not just this intersection segment. exists only at the last intersection,
      uuid = uuid,
      type = character/shape/harvestable/lift/joint/terrain/asset/limiter,
      normalWorld = some of the information from raycast,
      raydata = (unrestricted camera only and unsafe mode only or if connected to an unsafe computer from SComputers integrable) raw raycast result, allows you to get a raw handle of an object and do anything with it
  }

  maxdist is the maximum distance for raycast in meters.
  please note that the angle can be set from -82.5 to 82.5 degrees,
  it is transmitted in radians.
  limiter is the wall of the world.
  please note that not all types of objects have the "uuid" field.
  please note that getting the uuid of a block only works if it is no further than 4 meters (16 blocks) from the camera(this is done to maintain a balance) (this restriction does not apply to the unrestricted camera from power toys)
  
• camera.deepRawRay(x, y, maxdist, maxIntersections):intersections - it works the same way as camera.rawRay, but it sees through objects, giving out all intersections (unrestricted camera only)
• camera.setViewport(x, y, sizeX, sizeY) - you can specify the frame inside which the camera will display the image on the display. to reset you need call without arguments
• camera.getViewport():x, y, sizeX, sizeY - returns what was set using setViewport
• camera.resetDetectableObjects() - selects all the objects that the camera will see
• camera.setDetectableObjects({
  liquids = boolean,
  dynamicBody = boolean,
  staticBody = boolean,
  characters = boolean,
  joints = boolean,
  terrain = boolean,
  assets = boolean,
  harvestable = boolean
  }) - sets the list of objects that the camera will see, by default, all are selected
• camera.getDetectableObjects():table - returns a reference to the last table passed to setDetectableObjects. However, if you edit it, you must send it to setDetectableObjects again so that the camera can see the changes.
• camera.setImageRotation(rotation:number) - sets the image rotation in radians (default is 0)
• camera.getImageRotation():number - returns image rotation in radians (by default 0)
• camera.getSkyColor(constDayLightValue:number|nil):smcolor - returns the color of the sky that would be displayed in drawAdvanced, regardless of whether the camera sees the sky. can be used for use in drawCustom
• camera.getDayLightValue():number - returns the current time in the world. the host's sm.render.getOutdoorLighting() alias
• camera.getGlobalSunMul(constDayLightValue:number|nil):number - returns the multiplier of light for the sun, can be used with drawCustom and is calculated inside the function using the following formula: max(1 - (abs(getDayLightValue() - 0.5) * 2), 0.3)
• camera.drawOverlay(display, mainDrawFunction:function, args:table, overlayDrawer:function, overlayArgs:table) - combines any rendering mode with drawCustom
• camera.setDownScale(downscale:number) - reduces the resolution of the camera rendering by the specified number of times (default: 1)
• camera.getDownScale():number - returns the value set using setDownScale (default: 1)
• camera.setUseMaskForRawRay(state) - determines whether the "camera.setDetectableObjects" setting will be used for the "camera.rawRay" and "camera.deepRawRay" methods (default: false)
• camera.getUseMaskForRawRay():state
• camera.setCustomWorldPosition(vec3|nil) - set a custom world position that will be used instead of the real one on the camera until you set it to nil (default: nil) (unrestricted camera only)
• camera.setCustomWorldRotation(quat|nil) - set a custom world rotation that will be used instead of the real one on the camera until you set it to nil (default: nil) (unrestricted camera only)
• camera.setCustomLocalPosition(vec3|nil) - sets the offset of the camera's peephole (takes into account camera rotation) (default: nil) (unrestricted camera only)
• camera.setCustomLocalAfterPosition(vec3|nil) - sets the offset of the camera's peephole (ignores camera rotation) (default: nil) (unrestricted camera only)



unrestricted camera features (available in powertoys):

• there is no angle limit
• there is no limit on the distance to receive the UUID of the block
• direct access to raycast result (unsafe mode only or if connected to an unsafe computer from SComputers integrable)
• the ability to use "xray" (deep) methods that check multiple intersections
• using a fake position/rotation



xray camera

                --this code only works on unrestricted camera from power toys

local display = getComponent("display")
display.reset()
display.clear()
display.setSkipAtNotSight(true) --in order for the picture not to be updated for those who do not look at the screen

local camera = getComponents("camera")[1]
local fov = math.rad(60)
camera.setNonSquareFov(fov * (display.getWidth() / display.getHeight()), fov)
camera.setStep(512)

function callback_loop()
    if _endtick then
        display.clear()
        display.forceFlush()
        return
    end

    if display.getAudience() > 0 then
        camera.deepDrawCustom(display, function (x, y, intersections)
            local color = sm.color.new(0, 0, 0)
            local shapeIntersectionsCount = 0
            for i, intersection in ipairs(intersections) do
                if intersection.type == "shape" then
                    shapeIntersectionsCount = shapeIntersectionsCount + 1
                end
            end
            for i, intersection in ipairs(intersections) do
                if intersection.type == "shape" then
                    color = color + (intersection.color * (i / shapeIntersectionsCount) * 0.2)
                end
            end
            return color
        end, 4)
        display.flush()
    end
end
        




                local fastmode = false
                    
local display = getComponent("display")
display.reset()
display.clear()
display.setSkipAtNotSight(true) --in order for the picture not to be updated for those who do not look at the screen

local camera = getComponent("camera")
local fov = math.rad(60)
camera.setNonSquareFov(fov * (display.getWidth() / display.getHeight()), fov)
camera.setStep(512)

function callback_loop()
    if _endtick then
        display.clear()
        display.forceFlush()
        return
    end

    if display.getAudience() > 0 then --if no one is looking at the screen at all, then the camera will not work
        camera.drawOverlay(display, camera.drawAdvanced, {fastmode}, function(x, y, raydata)
            if not raydata then return end
            if raydata.type == "shape" then
                return sm.color.new(math.random(), 0, 0)
            elseif raydata.type == "character" then
                return sm.color.new(0, math.random(), 0)
            end
        end, {})
        display.flush()
    end
end
            




if you just want to get a picture on the screen, then use this code

                local fastmode = false
                    
local display = getComponent("display")
display.reset()
display.clear()
display.setSkipAtNotSight(true) --in order for the picture not to be updated for those who do not look at the screen

local camera = getComponent("camera")
local fov = math.rad(60)
camera.setNonSquareFov(fov * (display.getWidth() / display.getHeight()), fov)
camera.setStep(512)

local renderSettings = {
    lampLighting = not fastmode,
    shadows = not fastmode,
    smoothingTerrain = not fastmode,
    simpleShadows = true,
    sun = true, --is the solar disk being rendered
    fog = true,
    reduceAccuracy = true, --allows you to use fewer display effects in fog and simpleShadows, which increases performance in some cases

    constDayLightValue = nil, --you can make a constant time of day
    shadowMultiplier = 0.6,
    sunPercentage = 0.003, --this value is the percentage of the sun from the size of the sky
    simpleShadowMin = 0.3, --the minimum brightness of an object that a simple shadow can give
    simpleShadowMax = 1, --the maximum brightness of an object that a simple shadow can give

    customWaterColor = nil,
    customChemicalColor = nil,
    customOilColor = nil,

    constColor = nil, --allows you to make all objects in one color
    constSkyColor = nil, --by default, it depends on the time of day
    customSunColor = nil, --you can change the color of the sun
    constShapeColor = nil,
    customLiftColor = nil,
    constTerrainColor = nil, --you can make the whole terrain one color, even blue
    constCharacterColor = nil,
    constJointColor = nil,
    constHarvestableColor = nil, --allows all Harvestables to be the same color, instead of their real color
    constAssetsColor = nil, --you can set the constant color of assets so that it is always 1 and is not determined by the material

    customTerrainColor_dirt = nil,
    customTerrainColor_grass = nil,
    customTerrainColor_sand = nil,
    customTerrainColor_stone = nil,
}

function callback_loop()
    if _endtick then
        display.clear()
        display.forceFlush()
        return
    end

    if display.getAudience() > 0 then --if no one is looking at the screen at all, then the camera will not work
        camera.drawAdvanced(display, renderSettings)
        display.flush()
    end
end
            




render under mushrooms

                --this type of render does not have an optimization that transfers the render to the client, which leads to a strong ping in multiplayer
--in general, custom render is about 35% slower than the built-in similar options
--in addition, it does not have access to some of the data that advanced render uses
--in multiplayer, this code will run about 200% slower

local colors = require("colors")

local display = getComponents("display")[1]
display.reset()
display.clear()
display.setSkipAtNotSight(true) --in order for the picture not to be updated for those who do not look at the screen

local camera = getComponents("camera")[1]
local fov = math.rad(60)
camera.setNonSquareFov(fov * (display.getWidth() / display.getHeight()), fov)
camera.setStep(512)

function callback_loop()
    if _endtick then
        display.clear()
        display.forceFlush()
        return
    end

    if display.getAudience() > 0 then
        camera.drawCustom(display, function (x, y, raydata)
            if not raydata then
                return sm.color.new(0, math.random(), math.random())
            elseif raydata.type == "limiter" then
                return sm.color.new(math.random(), math.random(), math.random())
            elseif raydata.type == "terrain" then
                return sm.color.new(0, math.random(), 0)
            elseif raydata.type == "asset" then
                return sm.color.new(math.random(), 0, 0)
            end
            return sm.color.new(colors.hsvToRgb(((x + y) / 32) % 1, 1, 1)) * (raydata.color or sm.color.new(1, 1, 1))
        end)
        display.flush()
    end
end
            




It's like a thermal imager.

                --this type of render does not have an optimization that transfers the render to the client, which leads to a strong ping in multiplayer
--in general, custom render is about 35% slower than the built-in similar options
--in addition, it does not have access to some of the data that advanced render uses
--in multiplayer, this code will run about 200% slower

local display = getComponents("display")[1]
display.reset()
display.clear()
display.setSkipAtNotSight(true) --in order for the picture not to be updated for those who do not look at the screen

local camera = getComponents("camera")[1]
local fov = math.rad(60)
camera.setNonSquareFov(fov * (display.getWidth() / display.getHeight()), fov)
camera.setStep(512)

function callback_loop()
    if _endtick then
        display.clear()
        display.forceFlush()
        return
    end

    if display.getAudience() > 0 then
        camera.drawCustom(display, function (x, y, raydata)
            if not raydata or raydata.type == "limiter" then
                return 0x000000
            elseif raydata.type == "terrain" then
                return 0x00164e
            elseif raydata.type == "asset" then
                return 0x003554
            elseif raydata.type == "character" then
                return 0x880200
            elseif raydata.type == "shape" then
                return 0x875100
            end
            return 0
        end)
        display.flush()
    end
end
        




saving an image from the camera to disk
the saving takes place in the scimg8 format, which has an 8-bit palette
saving takes place using the image library

                --this simplest camera demonstrates the operation of the "image" library
--red button - make photo
--green button - show photo

local image = require("image")
local colors = require("colors")

local imagePath = "/image.scimg8"

local display = getComponent("display")
local disk = getComponent("disk")
local camera = getComponent("camera")

if input(colors.sm.Red[2]) then
    disk.clear()

    local img = image.new(display.getWidth(), display.getHeight(), sm.color.new(0, 0, 0))
    img:fromCameraAll(camera, "drawAdvanced")
    img:save8(disk, imagePath)

    display.clear("0000ff")
    display.drawText(1, 1, "photo maked!")
    display.forceFlush()
elseif input(colors.sm.Green[2]) then
    if disk.hasFile(imagePath) then
        local img = image.load(disk, imagePath)
        display.clear()
        img:draw(display)
        display.forceFlush()
    else
        display.clear("0000ff")
        display.drawText(1, 1, "no photo")
        display.forceFlush()
    end
end

function callback_loop()
    if _endtick then
        display.clear()
        display.forceFlush()
    end
end