To clarify, I was talking with a friend and we started to wonder if there were camera modes beyond orthographic and perspective. As an example, one that defined its edges not with a cuboid or frustum, but a curved volume?

There are all kinds of cool effects that could be done with that, especially if the curvature was animated. However, I know that perspective and orthographic modes are generally just done with matrices, so it might take some tinkering.

Blender is open to add on construction and open source at that, but I honestly have no idea where to begin. Would it be Python, or can I do it in OSL? Or would I have to actually dive into C for this?

Hopefully this question isn't too broad.

EDIT: I am purely attempting to extend the camera modes, not to simulate it with post processing (which has a number of additional drawbacks in efficiency). This question is about plugin development.

These are the familiar viewing transforms we use on a day to day basis, outlined by volume of rendered geometry (not volume of geometry, volume of rendered space) :

Perspective - smaller with depth:

Panoramic - projected from center in all direction:

Orthographic - same size:

In all cases, depth goes along a straight path in a specific direction, in Blender it's typically the camera's local Z. For panoramic, it is local r in sphere-space. Note that in all cases, depth is measured along straight lines, in a simplistic manner.

My proposal is to allow for the construction of cameras which are not confined to simplistic single-dimension radius, but actually measure depth along a curve:

As an example, with a rendering space which was defined like a curved volume, with a taper curve and a bevel curve, we could still define (in linear time) a path to each rendered pixel in Cycles; but that path would be unconstrained, and could say look at an object behind the red demo object. It would also only gather necessary data, where gathering all data from a panoramic camera and operating on that would still spend roughly six times the amount of time to render, plus post processing; and still wouldn't have all of the data necessary.

To clarify, I was talking with a friend and we started to wonder if there were camera modes beyond orthographic and perspective. As an example, one that defined its edges not with a cuboid or frustum, but a curved volume?

There are all kinds of cool effects that could be done with that, especially if the curvature was animated. However, I know that perspective and orthographic modes are generally just done with matrices, so it might take some tinkering.

Blender is open to add on construction and open source at that, but I honestly have no idea where to begin. Would it be Python, or can I do it in OSL? Or would I have to actually dive into C for this?

Hopefully this question isn't too broad.

EDIT: I am purely attempting to extend the camera modes, not to simulate it with post processing (which has a number of additional drawbacks in efficiency). This question is about plugin development.

These are the familiar viewing transforms we use on a day to day basis, outlined by volume of rendered geometry (not volume of geometry, volume of rendered space) :

Perspective - smaller with depth:

Panoramic - projected from center in all direction:

Orthographic - same size:

In all cases, depth goes along a straight path in a specific direction, in Blender it's typically the camera's local Z. For panoramic, it is local r in sphere-space. Note that in all cases, depth is measured along straight lines, in a simplistic manner.

My proposal is to allow for the construction of cameras which are not confined to simplistic single-dimension radius, but actually measure depth along a curve:

As an example, with a rendering space which was defined like a curved volume, with a taper curve and a bevel curve, we could still define (in linear time) a path to each rendered pixel in Cycles; but that path would be unconstrained, and could say look at an object behind the red demo object. It would also only gather necessary data, where gathering all data from a panoramic camera and operating on that would still spend roughly six times the amount of time to render, plus post processing; and still wouldn't have all of the data necessary.

To clarify, I was talking with a friend and we started to wonder if there were camera modes beyond orthographic and perspective. As an example, one that defined its edges not with a cuboid or frustum, but a curved volume?

There are all kinds of cool effects that could be done with that, especially if the curvature was animated. However, I know that perspective and orthographic modes are generally just done with matrices, so it might take some tinkering.

Blender is open to add on construction and open source at that, but I honestly have no idea where to begin. Would it be Python, or can I do it in OSL? Or would I have to actually dive into C for this?

Hopefully this question isn't too broad.

EDIT: I am purely attempting to extend the camera modes, not to simulate it with post processing (which has a number of additional drawbacks in efficiency). This question is about plugin development.

These are the familiar viewing transforms we use on a day to day basis, outlined by volume of rendered geometry (not volume of geometry, volume of rendered space) :

Perspective - smaller with depth:

Panoramic - projected from center in all direction:

Orthographic - same size:

In all cases, depth goes along a straight path in a specific direction, in Blender it's typically the camera's local Z. For panoramic, it is local r in sphere-space. Note that in all cases, depth is measured along straight lines, in a simplistic manner.

My proposal is to allow for the construction of cameras which are not confined to simplistic single-dimension radius, but actually measure depth along a curve:

As an example, with a rendering space which was defined like a curve, with a taper curve and a bevel curve, we could still define (in linear time) a path to each rendered pixel in Cycles; but that path would be unconstrained, and could say look at an object behind the demo red object. It would also only gather necessary data, where gathering all data from a panoramic camera and operating on that would still spend roughly six times the amount of time to render, plus post processing; and still wouldn't have all of the data necessary.

To clarify, I was talking with a friend and we started to wonder if there were camera modes beyond orthographic and perspective. As an example, one that defined its edges not with a cuboid or frustum, but a curved volume?

There are all kinds of cool effects that could be done with that, especially if the curvature was animated. However, I know that perspective and orthographic modes are generally just done with matrices, so it might take some tinkering.

Blender is open to add on construction and open source at that, but I honestly have no idea where to begin. Would it be Python, or can I do it in OSL? Or would I have to actually dive into C for this?

Hopefully this question isn't too broad.

EDIT: I am purely attempting to extend the camera modes, not to simulate it with post processing (which has a number of additional drawbacks in efficiency). This question is about plugin development.

These are the familiar viewing transforms we use on a day to day basis, outlined by volume of rendered geometry (not volume of geometry, volume of rendered space) :

Perspective - smaller with depth:

Panoramic - projected from center in all direction:

Orthographic - same size:

In all cases, depth goes along a straight path in a specific direction, in Blender it's typically the camera's local Z. For panoramic, it is local r in sphere-space. Note that in all cases, depth is measured along straight lines, in a simplistic manner.

My proposal is to allow for the construction of cameras which are not confined to simplistic single-dimension radius, but actually measure depth along a curve:

As an example, with a rendering space which was defined like a curved volume, with a taper curve and a bevel curve, we could still define (in linear time) a path to each rendered pixel in Cycles; but that path would be unconstrained, and could say look at an object behind the red demo object. It would also only gather necessary data, where gathering all data from a panoramic camera and operating on that would still spend roughly six times the amount of time to render, plus post processing; and still wouldn't have all of the data necessary.

To clarify, I was talking with a friend and we started to wonder if there were camera modes beyond orthographic and perspective. As an example, one that defined its edges not with a cuboid or frustrum, but a Bezier curve?

There are all kinds of cool effects that could be done with that, especially if the curve was animated. However, I know that perspective and orthographic modes are generally just done with matrices, so it might take some tinkering.

Blender is open to add on construction and open source at that, but I honestly have no idea where to begin. Would it be Python, or can I do it in OSL? Or would I have to actually dive into C for this?

Hopefully this question isn't too broad.

EDIT: I am purely attempting to extend the camera modes, not to simulate it with post processing (which has a number of additional drawbacks in efficiency). This question is about plugin development.

CLARIFICATION: I can see that using geometric terminology to describing viewing volumes is losing some of the SE, so allow me to (rapidly--sorry about that!) illustrate.

These are the familiar viewing transforms we use on a day to day basis, outlined by volume of rendered geometry. (Not volume of geometry, volume of rendered space.)

In all cases, depth is measured along a specific direction, in Blender it's typically the camera's local Z. For panoramic, it is local r in sphere-space. Note that in all cases, depth is measured along straight lines, in a simplistic manner.

My proposal is to allow for the construction of cameras which are not confined to simplistic single-dimension radius, but actually measure along a curve (not even necessarily a Bezier one, but a curved pseudo-dimension). This allows for rendering material which would otherwise simply not exist in the data set.

As an example, with a rendering space which was defined like a curve, with a taper curve and a bevel curve, we could still define (in linear time) a path to each rendered pixel in Cycles; but that path would be unconstrained, and could say look at an object behind the demo stop sign. It would also only gather necessary data, where gathering all data from a panoramic camera and operating on that would still spend roughly six times the amount of time to render, plus post processing; and still wouldn't have all of the data necessary.

To clarify, I was talking with a friend and we started to wonder if there were camera modes beyond orthographic and perspective. As an example, one that defined its edges not with a cuboid or frustum, but a curved volume?

There are all kinds of cool effects that could be done with that, especially if the curvature was animated. However, I know that perspective and orthographic modes are generally just done with matrices, so it might take some tinkering.

Blender is open to add on construction and open source at that, but I honestly have no idea where to begin. Would it be Python, or can I do it in OSL? Or would I have to actually dive into C for this?

Hopefully this question isn't too broad.

EDIT: I am purely attempting to extend the camera modes, not to simulate it with post processing (which has a number of additional drawbacks in efficiency). This question is about plugin development.

These are the familiar viewing transforms we use on a day to day basis, outlined by volume of rendered geometry (not volume of geometry, volume of rendered space) :

Perspective - smaller with depth:

Panoramic - projected from center in all direction:

Orthographic - same size:

In all cases, depth goes along a straight path in a specific direction, in Blender it's typically the camera's local Z. For panoramic, it is local r in sphere-space. Note that in all cases, depth is measured along straight lines, in a simplistic manner.

My proposal is to allow for the construction of cameras which are not confined to simplistic single-dimension radius, but actually measure depth along a curve:

As an example, with a rendering space which was defined like a curve, with a taper curve and a bevel curve, we could still define (in linear time) a path to each rendered pixel in Cycles; but that path would be unconstrained, and could say look at an object behind the demo red object. It would also only gather necessary data, where gathering all data from a panoramic camera and operating on that would still spend roughly six times the amount of time to render, plus post processing; and still wouldn't have all of the data necessary.